A Multi-Agent Collaborative Dynamic Workflow Control and Scheduling Method Based on Edge Environment
By deploying a multi-agent collaborative system in an edge computing network, the problems of large model illusion and insufficient dynamic adaptability in existing technologies are solved, and efficient and reliable intelligent workflow generation and scheduling are achieved, meeting the real-time and high availability requirements of industrial sites.
Patent Information
- Application Number
- CN202611394468.2
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-09-09
- Publication Date
- 2026-11-17
AI Technical Summary
Existing intelligent workflow generation and scheduling methods based on natural language commands suffer from problems such as large model illusion, high task-dependent error rate, slow inference speed, high token cost, insufficient dynamic adaptability, and high anomaly response latency, making it difficult to meet the real-time and high availability requirements of industrial sites.
Deploying a multi-agent collaborative system in an edge computing network, including a global planning agent, a dynamic task scheduling agent, and a local task generation agent, enables multi-dimensional verification, dynamic adaptation, and rapid response through vector retrieval, rule verification, incremental modeling, and anomaly recovery mechanisms.
It reduces large model illusions and task dependency errors, lowers dynamic scheduling response costs, improves system executability and production continuity, and meets the real-time and high availability requirements of industrial sites.
Smart Images

Figure CN123114682A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of intelligent control technology, specifically to a method for multi-agent collaborative dynamic workflow control and scheduling based on edge environments. Background Technology
[0002] Currently, intelligent workflow generation and scheduling methods based on natural language instructions typically rely on large language models for task decomposition, code generation, and dynamic programming. In existing solutions, the global planning phase uses a large model to directly output the workflow, but lacks effective verification and error correction mechanisms, making the large model prone to "illusions" and compromising task dependencies and action legitimacy. In the task scheduling phase, existing methods often require the large model to generate complete mathematical model code from scratch for each request, resulting in significant redundant computation, slow inference speed, high token costs, and low code executability and constraint satisfaction rates under complex constraints. In the local action generation phase, existing systems mostly employ a single strategy (such as using only a deterministic pattern defined by the planning domain definition language or only an interactive exploration pattern defined by ReAct), making it difficult to flexibly switch between well-defined and uncertain environments, leading to insufficient dynamic adaptability. Furthermore, existing solutions lack layered recovery mechanisms for abnormal scenarios such as model infeasibility and equipment malfunctions. Once the solution fails or execution anomalies, the system is prone to deadlock or task interruption, making it difficult to guarantee production continuity and physical executability.
[0003] The existing technology has at least the following problems: (1) The illusion of large models is serious, the generated abstract workflow lacks multi-dimensional verification, and the task dependency error rate is high; (2) The reasoning speed of generating complete solution code from pure large models is slow, the token cost is high, and the code execution rate and constraint satisfaction rate are low; (3) Each request in the dynamic scheduling process requires the generation of complete model code, resulting in high response costs; (4) There is a lack of efficient incremental update mechanism, and it is impossible to achieve hierarchical degradation such as semantic reflection, constraint relaxation, and baseline rollback when anomalies occur; (5) The local processing capabilities of the edge computing architecture are not fully utilized, the anomaly response latency is high, the cloud dependency is strong, and it is difficult to meet the real-time and high availability requirements of industrial sites. Therefore, there is an urgent need for a multi-agent collaborative workflow generation and scheduling method that can improve reliability, reduce costs, and has dynamic adaptability and edge collaboration capabilities. Summary of the Invention
[0004] To address the aforementioned technical problems, this invention proposes a multi-agent collaborative dynamic workflow control and scheduling method based on edge environments, comprising the following steps: Multiple edge nodes are deployed in an edge computing network, and each edge node is connected to a physical device and interconnected through a high-speed network. Receive natural language task instructions input by the user through edge nodes; The global planning agent generates an abstract task sequence containing multiple nodes with the support of a large language model in the cloud. The abstract task sequence adopts a directed acyclic graph structure, and retrieves relevant context through vector retrieval, constructs prompt words to input into the large language model for task decomposition and preliminary generation, and uses a rule validator for multi-dimensional verification and feedback. The dynamic task scheduling agent performs resource allocation and conflict management based on the abstract task sequence, understands user needs through the intent parsing layer, and transforms the intent into a mathematical model through the dynamic modeling layer; The dynamic modeling layer uses a large language model for incremental updates and maintains the consistency of variables and constraints through a runtime symbol library. The code execution layer uses a high-performance mathematical programming solver to solve the mathematical model and runs the solution code in a sandbox execution environment; If the solver returns an infeasible state, it will be handled according to the three-level anomaly recovery mechanism; The reasoning process of the global planning agent and the dynamic task scheduling agent is completed in the cloud, while the local task generation agent is executed on the edge node to generate specific action instructions and drive the physical device.
[0005] Furthermore, the generation of the abstract task sequence by the global planning agent further includes: Domain knowledge documents are vector-encoded and then stored in a vector database; Upon receiving the natural language instruction, the relevant reference context is retrieved from the vector database and loaded into the compliance action set; Construct a prompt word that includes the natural language instruction, the reference context, and the set of compliant actions, and input the prompt word into the large language model; The large language model performs task decomposition and outputs a preliminary task graph, and the rule validator performs format, loop and action legality checks on the preliminary task graph. If the validation succeeds, the final abstract workflow is output; if the validation fails, an error feedback message is generated and a replanning is triggered. The vector retrieval and rule verification processes are assisted by lightweight modules on the edge nodes.
[0006] Furthermore, the resource allocation by the dynamic task scheduling agent further includes: The intent parsing layer includes a RAG vector retrieval module, a parameter weight parsing module, a semantic routing module, and a rescheduling module; The dynamic modeling layer includes an LLM incremental modeling module, a runtime symbol library module, a code model integration module, and a constraint relaxation module; The LLM incremental modeling module extracts current context information, obtains a symbolic snapshot of the current model, organizes the information and symbolic snapshot into logical triples, and inputs them into the large language model to generate incremental patches. The incremental patch, after being verified in a security sandbox, is used to update the model matrix; The constraint relaxation module and the security sandbox verification are executed locally on the edge node to reduce cloud call overhead.
[0007] Furthermore, the local action generation further includes: For deterministic scenarios with clear rules and fully known states, a planning domain definition language pattern is adopted. After symbolic solving, semantic translation and syntax verification are performed on the edge nodes, the action plan is directly output. For uncertain scenarios with dynamic environmental changes and incomplete information, the ReAct dynamic exploration mode is adopted, which interacts with the environment through the edge nodes and gradually approaches the target through iterative cycles. Based on the planning suitability score calculated by the edge nodes, dynamic switching is performed between the PDDL mode and the ReAct mode.
[0008] Furthermore, the processing based on the three-level anomaly recovery mechanism includes: The first level is the semantic reflection level, which uses irreducible and infeasible subset analysis to locate the minimum set of conflicting constraints and retains all user intent by adjusting the model expression or repairing logical conflicts. The second level is the constraint relaxation level. When the semantic reflection level cannot resolve the conflict, a suboptimal relaxation solution is obtained by relaxing non-critical constraints or introducing penalty variables. The third level is the baseline rollback level. When the first two levels fail, all incremental patches are discarded and the system rolls back to a pre-defined baseline scheme that only guarantees physical security. The irreducible infeasible subset analysis is performed locally at the edge node, and only the simplified conflict description is uploaded to the cloud.
[0009] Furthermore, it also includes: When a device malfunction occurs during task execution, the edge node immediately performs preliminary deviation identification locally, and retrieves real-time data of the current device and digital twin model data for comparison; Causal decoupling is achieved through a structured state divergence model, generating attribution vectors that include primary and secondary causes; The attribution vectors are uploaded to a large language model in the cloud and combined with a policy optimization knowledge base for reasoning, so as to reconstruct a flexible policy optimization graph for decision-making. The reconstructed graph is distributed from the cloud to each edge node to enable edge-end collaborative decision-making; Edge nodes synchronize status information through a publish-subscribe mechanism to ensure coordinated actions among multiple devices.
[0010] Furthermore, it also includes: Based on the initial scheduling requirements and equipment capabilities, the resource function vectors of each task node are extracted; Constraints that meet the preset conditions are directly mapped to model weights through the parameter fast channel; Personalized constraints are input into the incremental slow channel, processed by the dynamic modeling layer, and incremental constraint code is generated. The parameter fast channel operates entirely locally on the edge node, while the incremental slow channel only invokes the cloud-based large language model when needed.
[0011] Compared with the prior art, the present invention has the following beneficial technical effects: The global planning agent in this application employs knowledge retrieval, structured output, and multi-dimensional verification, which can reduce large model illusions and task-dependent errors. The PSS mechanism enables the system to dynamically switch between PDDL and ReAct, quickly generating verifiable actions when the environment is clear, and completing tasks through interactive exploration when the environment is uncertain.
[0012] This application reduces the dynamic scheduling response cost. Regular scheduling preferences are completed through the parameter fast channel, while personalized constraints enter the incremental slow channel, avoiding the generation of complete model code for each request. It also reduces errors in generating large model code, limits variable and index space through runtime symbol snapshots, and uses sandbox verification to block dangerous operations and illegal references, thereby improving the executable rate of incremental constraint code.
[0013] This application's system provides semantic reflection, constraint relaxation, baseline rollback, and replanning mechanisms when models are infeasible, equipment malfunctions, or actions fail, prioritizing physical executability and production continuity. It facilitates engineering expansion; tasks, robots, constraints, and scheduling results utilize structured data models, with loosely coupled modules for action generation, scheduling solution, and result parsing, allowing integration with different robots, solvers, and large models. Furthermore, in a collaborative computing architecture within an edge environment, local anomalies can be rapidly processed at edge nodes, with only structured data uploaded to the cloud, significantly reducing network bandwidth consumption and anomaly response latency. Edge nodes synchronize their states through a publish-subscribe mechanism, enabling multi-device collaborative decision-making and ensuring production continuity and robustness in dynamic environments. Attached Figure Description
[0014] Figure 1 Design diagram of a hierarchical multi-agent collaborative framework; Figure 2 Generate coarse-grained flowcharts for tasks at the global planning layer; Figure 3A flowchart comparing the two local action generation strategies; Figure 4 This is a structural diagram of a dynamic scheduling model based on incremental modeling. Figure 5 The flowchart for dynamic injection of incremental constraints based on symbol awareness is shown below. Figure 6 This is a diagram of a three-level anomaly recovery mechanism model. Detailed Implementation
[0015] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.
[0016] Example 1 This embodiment addresses the task of assembling precision parts from area A into components and transporting them to area B in an electronics assembly workshop. Prioritizing assembly accuracy while also considering efficiency, the task utilizes micro-pitch ball grid array (BGA) packaged chips and flexible circuit boards. Assembly tolerances require micrometer-level high precision, and the force control threshold is set to a predetermined safety value. The workshop deploys a dual-arm collaborative robot A, an automated guided vehicle (AGV) B, and a conveyor belt C. Robot A is equipped with a force-controlled gripper and a 2D / 3D vision system, while AAV B possesses medium load capacity and millimeter-level positioning accuracy.
[0017] This embodiment employs an edge collaborative computing architecture, deploying multiple edge nodes in the workshop, connecting robot A, automated guided vehicle B, and conveyor belt C respectively. Each edge node is interconnected via a high-speed industrial Ethernet and communicates with a large language model server in the cloud. The edge nodes are equipped with dedicated acceleration units and real-time operating systems, supporting low-latency inference and data preprocessing. Preliminary processing of visual data is completed at the edge nodes, with only structured features uploaded to the cloud, significantly reducing network bandwidth consumption.
[0018] according to Figure 1 The layered intelligent task planning and execution system shown decomposes and optimizes complex natural language instructions layer by layer, ultimately transforming them into a specific sequence of actions that can be executed by physical devices. The system consists of six main layers, each with a clear division of labor and working collaboratively.
[0019] The first layer is the input and knowledge support layer. This layer is responsible for receiving natural language task instructions from users and relies on three core modules to provide necessary support capabilities. The first module is the LLM access module, which is responsible for understanding the user's natural language intent and converting unstructured text into a semantic representation that the system can process. The second module is the RAG knowledge storage module, which provides enhanced retrieval capabilities from external knowledge bases, helping the system understand the task context or domain-specific rule constraints, thereby compensating for the shortcomings of general-purpose large models in vertical domain knowledge. The third module is the workflow verification module, which is used to verify whether the subsequently generated workflow conforms to basic logical specifications or constraints, ensuring the correctness and executability of the process.
[0020] The second layer is the global planning layer. This layer undertakes macro-level decision-making functions, responsible for abstracting complex natural language instructions into a logical execution blueprint. Its output is an abstract task sequence. This sequence is organized in the form of a directed acyclic graph. This structure ensures that there are clear dependencies between tasks and avoids the problem of circular deadlocks, providing a clear logical framework for subsequent scheduling and execution.
[0021] The third layer is the task scheduling layer. After the abstract task sequence is generated, the dynamic task scheduling agent takes over the processing flow, responsible for resource allocation and conflict management. This agent contains three key modules. The first module is the problem modeling module, which is responsible for transforming scheduling requirements into mathematical models, such as integer programming models, thereby formalizing the practical problem into a computable structure. The second module is the Gurobi solver module, which calls a high-performance mathematical programming solver to calculate the optimal task execution order or resource allocation scheme. The third module is the conflict resolution module, which handles the competition between tasks in terms of execution time or hardware resources, ensuring that the final scheduling scheme is feasible and can meet the operational constraints of the actual physical system.
[0022] The fourth layer is the local generation layer, also known as the task decomposition layer. The abstract tasks, after scheduling optimization, are passed to this layer, as shown by the two parallel nodes Ti and Tj in the diagram. This layer represents the system's local splitting of the global task, allowing different abstract task nodes to be processed in parallel or independently, thereby improving overall execution efficiency and reducing the processing burden on individual nodes.
[0023] The fifth layer consists of local task generation agents, also known as the action generation layer. Corresponding to the two abstract task nodes Ti and Tj, the system has two or more functionally consistent local task generation agents. Each agent is responsible for transforming a specific abstract task into concrete action instructions, and each agent contains three sub-modules. The first sub-module is the adaptive selection module, which intelligently selects the optimal generation strategy based on the current task type and environment state. The second sub-module is the PDDL generation module, which generates a standard planning domain definition language description; this formal description is suitable for classic planning solution methods. The third sub-module is the ReAct generation module, which generates prompts or logical structures that combine reasoning and action, suitable for dynamic decision-making scenarios driven by large models.
[0024] The sixth layer is the physical device execution layer, which is also the lowest layer of the entire system. Ultimately, the specific instructions generated by the local intelligent agent are transformed into executable action sequences that can be directly recognized by the physical devices. In the diagram, the corresponding action sequence Ai is output by node Ti, and the corresponding action sequence Aj is output by node Tj. These action sequences ultimately drive the actual mechanical devices or software terminals to perform specific task operations, completing the full feedback from natural language instructions to physical execution.
[0025] Figure 2 This diagram illustrates the coarse-grained generation process for global planning layer tasks. It showcases an automated workflow generation system based on a large language model and retrieval-enhanced generation techniques. The system transforms user-input natural language commands into verifiable and executable abstract task graphs, employing a directed acyclic graph structure and a rigorous verification mechanism to achieve self-correction. The entire generation process can be clearly divided into three progressive stages.
[0026] The first phase is the RAG and Prompt construction phase, also known as the knowledge enhancement and input preparation phase. The main task of this phase is to prepare high-quality input context information for the reasoning process of the large language model. Regarding domain knowledge processing, the system first performs vector encoding on the domain knowledge documents and stores the encoded vector data in a vector database for subsequent retrieval. For context retrieval, after receiving a user command, the system performs a vector retrieval operation on the command, recalling reference context information related to the current command from the vector database. Regarding compliance constraints, the system simultaneously loads a set of compliant actions, also known as a set of legal actions. This set is used to limit the scope of actions output by the large language model, ensuring that the generated content does not exceed the executable domain. Finally, in the Prompt construction phase, the system integrates and concatenates the user command, reference context, and set of legal actions to form a structured prompt word, which is then passed to the large language model in the next phase.
[0027] The second stage is the core inference stage of the large model, namely the task decomposition and preliminary generation stage. The completed Prompt is then formally input into the large language model. This model executes the task decomposition logic, breaking down complex user instructions into structured task nodes, and finally outputs a preliminary task graph. This graph is usually represented in a structured data format such as JSON to facilitate subsequent programmatic processing.
[0028] The third stage is the verification and error handling stage, which is the core error correction and feedback link to ensure output quality. The system sends the preliminary task graph to the rule validator for multi-dimensional hard checks. The verification content includes JSON format verification to verify whether the output is valid structured data; DAG cycle detection to check whether there are circular dependencies in the task graph, because the DAG structure must ensure that the graph is cycle-free; action legality detection to verify whether each action in the graph is included in the set of compliant actions provided in the first stage; dependency resolution and constraint verification to check whether the dependencies between tasks are reasonable and to verify whether resource constraints or time constraints are met.
[0029] After completing the above verifications, the system enters the branch decision and feedback loop. If the verification is successful, meaning all checks pass, the system will execute the DAG construction operation, outputting the final abstract workflow, and the entire process ends. If the verification fails, meaning any check fails, the system will generate detailed error feedback information and trigger a process replanning. This error information will be sent back to the upstream module, typically the large language model or the Prompt construction layer, requiring the large language model to correct its output based on the error message until all verification items pass. This feedback design effectively ensures that the final generated abstract workflow conforms to domain specifications and is logically executable.
[0030] The large language model employs a large-scale parameter model for semantic decomposition, generating a flexible strategy optimization atlas. This atlas contains several task nodes, including a visual positioning node for flexible circuit boards, a high-precision chip grasping node, a force-controlled assembly node, a screw fastening node, a solder joint detection node, a transport to area B node, and a secondary quality inspection node. The nodes are sequentially dependent, meaning the next node executes after the previous one is completed. They also contain resource mutual exclusion constraints, meaning the force control sensor is only available to robot A.
[0031] The dynamic task scheduling agent extracts the required capabilities and loads of each node based on this graph, generating a resource function vector. Taking the force-controlled assembly node as an example, its resource function vector includes clamping force requirements, positioning accuracy requirements, load index, and environmental cleanliness requirements.
[0032] Figure 4For dynamic scheduling models based on incremental modeling, an intelligent solution system for user natural language scheduling needs is presented. The system adopts a three-layer architecture and has an error feedback mechanism, enabling a complete processing flow from intent understanding to model solving and adaptive error correction.
[0033] The system's top layer consists of user-defined natural language scheduling requirements. The system receives scheduling tasks described by users in natural language; these tasks typically include production scheduling, resource allocation, and other practical scenarios. Users do not need to master professional modeling languages or programming knowledge; they can trigger the system's complete processing chain simply by expressing their scheduling goals and constraints in natural language.
[0034] The first layer of the system is the intent parsing layer. This layer is responsible for deep semantic understanding of user input and transforming it into modelable structured information, comprising four core modules. The first module is the RAG vector retrieval module, which uses retrieval-enhanced generation technology to retrieve reference information relevant to the current need from historical case libraries or knowledge bases, assisting the system in accurately understanding user intent. The second module is the parameter weight parsing module, which extracts key parameters from user commands, involving multiple dimensions such as time, resources, and priority, while also parsing the weights of each objective function, such as determining whether the user prioritizes cost or efficiency. The third module is the semantic routing module, which routes requests to the most appropriate processing flow or model based on task type, such as distinguishing between urgent and routine tasks and adopting different processing strategies accordingly. The fourth module is the rescheduling module, which triggers rescheduling logic to restart the planning process in response to changes when the system detects that the original plan is infeasible or receives new dynamic instructions.
[0035] The second layer of the system is the dynamic modeling layer. This layer is responsible for transforming the parsed intent into a computable mathematical model and supporting the dynamic evolution of the model during runtime. It comprises four modules. The first module is the LLM incremental modeling module, which uses a large language model to incrementally update the model based on new information, rather than rebuilding the entire model from scratch each time, thus significantly reducing modeling overhead. The second module is the runtime symbol library module, which maintains various symbols used in the modeling process, including variables, constraints, objective functions, and their corresponding semantic mapping relationships, ensuring the interpretability and consistency of the model throughout its runtime. The third module is the code model integration module, which integrates the generated mathematical model with existing code frameworks or historical models to achieve modular reuse and avoid redundant development. The fourth module is the constraint relaxation module, which allows for the appropriate relaxation of certain soft constraints when the original constraint set results in an infeasible solution, generating an approximate feasible solution and feeding back the relaxation information to the user for decision-making adjustments.
[0036] The third layer of the system is the code execution layer. This layer is responsible for the actual solution and handling various exceptions that occur during execution, and consists of three core parts. The first part is the Gurobi solver, which calls a high-performance mathematical programming solver to accurately solve the constructed mathematical model. The second part is the sandbox execution environment, which runs the solution code in an isolated and secure environment, effectively preventing malicious or erroneous code from affecting the main system. The third part is the IIS semantic reflection module. When the model has no solution, this module uses irreducible infeasible subset analysis technology to accurately locate the set of constraints causing the conflict, and uses semantic reflection capabilities to generate readable conflict explanations to help users or upper-layer modules make targeted corrections.
[0037] The system's bottom layer houses the error feedback mechanism. Errors generated at the execution layer or throughout the process are fed back to upper-level modules, specifically the rescheduling module or the dynamic modeling layer, thus forming a complete feedback control system. This design enables the system to achieve adaptive error correction capabilities, automatically adjusting strategies when encountering anomalies to ensure robustness and solveability in dynamically changing environments. Overall, the system achieves efficient transformation from natural language to feasible scheduling schemes through the close collaboration of four stages: intent parsing, dynamic modeling, code execution, and error feedback.
[0038] Figure 5 This diagram illustrates the symbol-aware incremental constraint dynamic injection process. Figure 4 This document details the internal workflow of the LLM incremental modeling module, demonstrating how to leverage a large language model to achieve efficient incremental updates. The entire process comprises seven progressive steps.
[0039] The first step is the extraction step. The system extracts the key information needed for the update from the current context, which comes from various sources including new user commands, environmental change information, and error feedback.
[0040] The second step is the symbolic snapshot step. The system obtains a symbolic state snapshot of the current model, which includes the existing set of variables, constraints, and objective functions, serving as a benchmark for subsequent update operations.
[0041] The third step is the logical triple step. The system organizes the extracted key information and symbol snapshots into structured logical triples, typically in the form of a relationship between entities. This structured format facilitates understanding and manipulation by large language models.
[0042] The fourth step is the LLM dynamic modeling and coding module, which is the core of the entire process. Based on the input content mentioned above—symbolic snapshots and logical triples—the large language model generates incremental patches. These incremental patches are essentially a set of modification instructions for the existing model, including adding new variables, adjusting constraint coefficients, and modifying target weights, among other things.
[0043] The fifth step is the incremental patch output step. As the output of the large language model, the incremental patch details the specific changes that need to be applied to the current model.
[0044] The sixth step is the matrix update step. The system applies incremental patches to the model matrices, including constraint matrices and coefficient matrices, to complete the substantial numerical update of the model.
[0045] The seventh step is the security sandbox process. The system verifies the updated model in an isolated, secure environment to ensure its syntax is correct, its logic is consistent, and it is solvable, guaranteeing that the update will not introduce any errors or security vulnerabilities. Only after successful sandbox verification will the new model be officially delivered to the solver for further solving.
[0046] In practical application scenarios, the system inputs the resource function vector to... Figure 4 and Figure 5 The solver shown uses a mathematically optimized solver as the underlying computational engine in its basic model.
[0047] The fast parameter path maps user requirements that prioritize accuracy into a reasonable weighting of accuracy and time objectives, ensuring a balance between the two types of metrics. The slow incremental path handles personalized constraints, including the specific requirements of force control sensors and special conditions such as environmental cleanliness levels.
[0048] During operation, the solver scans runtime symbol snapshots, extracts variable information and the robot capability matrix, and injects incremental constraint code into the sandbox environment. The entire constraint resolution process is extremely fast, and the sandbox validation achieves a perfect pass rate.
[0049] After the above process, the system finally generates a resource allocation plan. In this plan, robot A performs visual positioning, grasping, force-controlled assembly, screw fastening, weld inspection, and secondary quality inspection tasks, while automated guided vehicle B performs transportation tasks. The combination of various strategy nodes constitutes a complete set of execution task data.
[0050] During the local motion generation phase, the system calculates the planning suitability score for robot A. The multi-dimensional evaluation indicators used in the calculation show that the environmental state integrity is high, all part poses have been identified, parameter integrity is high, instruction ambiguity is low, the task span coefficient is within a reasonable range, environmental dynamism is low, and historical feedback indicates a high success rate for the planning domain definition language. These indicators collectively validate the effectiveness and feasibility of the system planning scheme.
[0051] Figure 3 This diagram compares the workflows of two local action generation strategies. It clearly contrasts two distinct technical paths for transforming abstract tasks into concrete actions: the ReAct dynamic exploration mode (interactive loop mode) shown on the left, and the PDDL deterministic generation mode (linear pipeline mode) shown on the right. These two modes differ fundamentally in their workflow structure, environmental dependencies, and applicable scenarios.
[0052] The first mode is the PDDL deterministic generation mode, also known as the linear pipeline mode. This is a classic planning-as-a-solution mode, where the process is a straight, unidirectional line with no feedback interaction with the environment during the entire operation. The starting point of this mode is an abstract task. The system first performs symbolic solving, using the domain-defined language of planning to perform formal logical deduction and generate a global symbolic plan. Then, the system performs semantic translation, translating the symbolic logical expression into semantic instructions that can be understood by machines or humans. Next, the system proceeds in a unidirectional linear direction, and performs strict syntax checks on the generated instructions to ensure that the output strictly conforms to the specifications of the domain-defined language of planning. Finally, after successful verification, the system directly issues commands and outputs the final action plan. The core feature of this mode is that the entire process does not require external environmental feedback, relying entirely on a complete prior knowledge model to achieve one-step planning. This mode is suitable for deterministic scenarios with clear rules, completely known states, and no need for mid-process adjustments, such as the classic block-world planning problem.
[0053] The second mode is the ReAct dynamic exploration mode, also known as the interactive loop mode. Inspired by reinforcement learning and cognitive science, this reasoning-action-observation loop mode emphasizes dynamic interaction with the environment. The mode begins with the system outputting an action to the external environment and receiving environmental feedback and observations. The system then enters a thinking and reflection phase, reasoning based on the observed feedback and performing self-reflection to evaluate the rationality of the action just performed or to assess the gap between the current state and the target state. Next, the system performs action translation, translating the revised strategy formed after reflection into specific action instructions. After translation, the system iterates, re-entering the environment with new actions, thus forming a complete feedback loop. During this process, the memory module continuously accumulates historical interaction information, providing long-term and short-term contextual support for subsequent thinking phases. The core characteristic of this mode is that it is a trial-and-error and adaptive process, not pursuing perfect planning in one go, but gradually approaching the goal through repeated interactions. This mode is suitable for open-world tasks with dynamically changing environments and incomplete information, such as robot navigation or web page operations.
[0054] Regarding the relationship between the two modes and overall process management, the process module in the diagram acts as a global execution controller. In PDDL mode, the process module is responsible for driving the sequential advancement of each pipeline step. In ReAct mode, the process module is responsible for managing the termination conditions of the loop, i.e., determining when to stop iteration. Meanwhile, the memory module plays a crucial role in the ReAct loop; it not only stores historical trajectory information but also serves as an experience base for PDDL symbolic solution failures, aiding subsequent decision-making.
[0055] After weighted calculation, the planning suitability score is higher than the predetermined threshold, therefore the system selects... Figure 3 The left side shows the planning domain definition language path. Within this framework, the domain file defines multiple action primitives. The solver generates atomic action sequences in a very short time. These sequences include fine-grained operations such as force search, alignment, and increasing contact force to a predetermined value. On the other hand, due to its low environmental dynamics score, the automated guided vehicle B's planning suitability score is below the threshold; therefore, the system selects… Figure 3 The ReAct interactive exploration engine shown on the right adjusts the transport path in real time based on LiDAR data to cope with dynamically changing environmental conditions.
[0056] When the screw fastening node was reached, the torque curve recorded by the end effector torque sensor of robot A showed an abnormal spike, exceeding the upper limit, triggering abnormal response data. The event communication module correlated this anomaly to the corresponding strategy node. The system immediately retrieved high-resolution visual data and high-sampling-rate torque data and compared them with the digital twin model. The expected curve of the digital twin was a smooth rise followed by stability, while the actual curve showed fluctuating components. Quantitative analysis of the deviation data showed significant torque deviation and abnormal fluctuation frequency, and visual inspection revealed the presence of tiny foreign objects at the edge of the screw hole.
[0057] The structured state divergence model initiates causal decoupling analysis, utilizing a pre-trained Bayesian network for vectorized attribution. This Bayesian network, trained on a large amount of historical assembly data, achieves extremely high accuracy. The primary attribution vector output is thread foreign matter, contributing the most; the secondary cause is tool wear, contributing less; the conflict constraint is the torque upper limit. This attribution vector is input into a large language model, combined with a policy optimization knowledge base containing rich correction records for reasoning. The model infers that there is debris at the current hole position, requiring an additional cleaning step, and reconstructs the flexible policy optimization graph. The reconstructed graph inserts an air-blowing cleaning node before the screw fastening node and adjusts the torque monitoring window of the screw fastening node. The reconstructed graph passes all multiple validity checks. The scheduling layer assigns the air-blowing cleaning node to robot A for execution, slightly increasing the total assembly cycle. After re-execution, the peak fastening torque returns to normal, fluctuations disappear, and the assembly yield recovers to an extremely high level.
[0058] In this embodiment, edge collaborative computing plays a crucial role. Upon detecting an anomaly in torque, the edge node of robot A can complete preliminary deviation identification locally without waiting for a cloud response, only uploading structured deviation data to the cloud attribution model. After the cloud-based large language model completes the graph reconstruction, incremental updates are distributed to each edge node, enabling edge-end collaborative decision-making. Edge nodes synchronize status information through a publish-subscribe mechanism. When robot A performs air-blowing cleaning, the edge node of the automated guided vehicle (AGV) receives the status update in advance and proactively adjusts its approach speed to avoid waiting. This edge collaborative mechanism significantly reduces end-to-end latency in anomaly response. Data from this embodiment shows that the planning suitability score mechanism significantly reduces action generation time, achieves extremely high accuracy in deviation analysis attribution, and has a high first-time success rate after graph reconstruction. Edge node resource usage is reasonable, and communication latency is extremely low, meeting the real-time requirements of industrial sites.
[0059] Example 2 The initial task in this embodiment is to sequentially inspect, repair, and weld multiple sheet metal parts, with multiple robots permanently stationed in the workshop. Robot A is a dedicated welding robot with a large payload; robots B and C are inspection and repair robots with smaller payloads. The system first generates an initial flexible strategy optimization map, containing multiple task nodes. Each workpiece corresponds to an inspection node, a repair node, and a welding node. Workpieces have a sequential dependency relationship; within the same workpiece, inspection, repair, and welding are executed sequentially, with clear order constraints between tasks.
[0060] This embodiment deploys an edge collaborative computing architecture, with multiple edge computing servers configured in the workshop, communicating with each robot via a high-speed wireless network. The edge servers are responsible for real-time monitoring and decision-making regarding welding and inspection / repair tasks, respectively. The servers synchronize map status and resource allocation information through a high-speed data channel. The cloud-based large language model serves as global decision support, only being invoked in complex situations such as constraint conflicts. The edge servers make very few daily calls to the cloud, significantly reducing network dependence.
[0061] At the start of execution, the user adds the following instructions: the inspection task must be completed before the repair task, and robot A cannot perform welding; inspection and repair should be completed by the same robot as much as possible to ensure data consistency. Figure 4 As shown in the intent parsing layer, the dynamic task scheduling agent parses the first two instructions into temporal constraints and mutual exclusion constraints, and the third instruction into binding constraints. These constraints are then processed in the incremental slow channel. The system creates a runtime symbolic snapshot, extracting variables, the task identifier set, and the robot capability matrix, where welding capability is possessed only by robot A. During incremental code generation, the large language model generates incremental constraint code within a restricted symbolic context, and sandbox validation passes. However, the solver returns an infeasible state after the constraints are injected.
[0062] Figure 6 This diagram illustrates a three-tiered anomaly recovery mechanism model. It showcases a three-level adaptive fault-tolerance and fallback solution mechanism specifically designed to handle degradation strategies in scheduling optimization models when no feasible solution is available. This mechanism follows a fundamental principle of decreasing priority from high to low. The system prioritizes the optimal solution that 100% preserves the user's intent. When a solution attempt fails, the system progressively backs down according to the tiered order until it outputs a minimum fallback solution that guarantees the safe operation of physical devices, thereby effectively preventing system crashes.
[0063] The first level is the semantic reflection level, which is the highest priority level in the entire mechanism. Its core goal is to preserve 100% of the user's original intent and output the optimal solution. The specific working mechanism of this level is to invoke irreducible infeasible subset analysis techniques to accurately locate the minimum set of conflicting constraints that cause the mathematical model to be unsolvable. This level does not sacrifice any user goals or hard constraints when executing actions; instead, it eliminates contradictions through semantic reflection—that is, adjusting the model's expression or repairing logical conflicts. The result of this level is that if conflicts can be successfully repaired, a scheduling scheme that perfectly matches the user's needs is directly obtained.
[0064] The second level is the constraint relaxation level, which has a medium priority in the entire mechanism. This level is triggered when the semantic reflection of the first level fails to resolve the conflict, or the cost of resolution is too high. The core objective of this level is to output a relaxed solution with a penalty term. Its key is to achieve feasible scheduling, but this reduces the accuracy of user intent to some extent. The specific mechanism of this level involves two operations. The first operation is to proactively relax some non-critical constraints, such as appropriately extending delivery deadlines or allowing a small amount of overtime. The second operation is to introduce penalty variables, i.e., relaxation variables, allowing constraints to be violated, but imposing a corresponding penalty cost in the objective function. Through these two operations, the system effectively expands the solution space, enabling the solver to find a mathematically feasible suboptimal solution with the lowest penalty cost. The result of this level is the sacrifice of some non-core indicators, such as minor time delays, in exchange for the continued progress of the overall process.
[0065] The third level is the baseline rollback level, the lowest level of the entire mechanism. This level is triggered when the first two levels fail or the solution time exceeds a preset limit. The goal of this level is to output a safety net solution, ensuring only the bare minimum physical feasibility, such as hard safety rules like preventing equipment overload and continuous personnel work. The specific mechanism of this level also includes two aspects. The first aspect is discarding all incremental patches, abandoning all current complex dynamic modeling optimization logic and added constraints. The second aspect is rolling back to a pre-defined, absolutely safe baseline solution, such as a pre-stored standard emergency plan or a manually formulated fallback plan. The result of this level is that the final solution may deviate significantly from the user's optimal intent, but it absolutely guarantees the safety and basic physical feasibility of the physical equipment during execution, effectively preventing system deadlock or equipment damage.
[0066] in accordance with Figure 6As shown in the flowchart, the system enters a multi-level anomaly recovery mechanism when encountering an anomaly. After the first level of semantic reflection is initiated, the irreducible conflict set analysis outputs a conflict set, which specifically includes the conflict item of negating the value of the welding task assigned to robot A and the conflict item of the welding capability uniqueness constraint. The natural language diagnostic results are fed back to the large language model for processing. At the same time, the system constructs a structured state divergence model, collects the current utilization data, capability vector data, and environmental state data of each robot, compares and analyzes these data with the ideal digital twin model, generates deviations, and decouples them into an attribution vector. This attribution vector contains information in multiple dimensions, where the conflict type is capability uniqueness, the disabled equipment is robot A, the required capability is welding, the alternative is none, and the resource gap degree is complete.
[0067] After receiving the above information, the large language model performs strategy optimization analysis in conjunction with a strategy optimization knowledge base, which stores a large number of constraint conflict case records. Based on this, the model generates several candidate reconstruction schemes. The first candidate scheme is to dispatch a mobile welding robot from a nearby work area. This scheme has a high capability matching degree and a short expected arrival time. The second candidate scheme is to outsource the welding task to a manual workstation. This scheme has a significantly increased expected cycle time. The third candidate scheme is for robot C to temporarily borrow the welding gun of robot A. However, robot C has insufficient load capacity and requires the addition of an auxiliary positioning mechanism. The success probability of this scheme is predicted to be moderate.
[0068] The three candidate solutions were evaluated using digital twin simulation, and the evaluation time was within a reasonable range. Simulation results showed that the first solution resulted in the least increase in project duration, while the third solution had a higher execution risk. Based on the evaluation results, the model decided to adopt the first solution and reconstructed the flexible strategy optimization graph. The reconstructed graph added a scheduling node for the mobile welding robot's entry and a preparation node, changed the allocation target of all welding tasks from robot A to the mobile welding robot, and adjusted the dependencies between related tasks. After this reconstruction, the number of nodes and the number of dependent edges in the graph both increased.
[0069] As a safeguard mechanism, the third-level baseline rollback will remove the binding constraints if the mobile welding robot is unavailable. The inspection task and repair task will be separated and executed by robot B and robot C respectively, while alarm information will be recorded for operators to review.
[0070] In the final implementation of this embodiment, the arrival time of the mobile welding robot was better than estimated. After the welding task was assigned, the solver found the optimal solution in a short time. The total work order completion time was slightly longer than originally planned, but the increase was within an acceptable range. The success rate of automatic constraint conflict recovery was high, based on statistics from multiple random injection experiments. The average reconstruction time was short.
[0071] Edge collaborative computing in this embodiment is manifested in the following aspects. When the solver returns an infeasible state, the edge server immediately performs irreducible conflict set analysis locally, extracts the core of the conflict, and uploads the simplified conflict description to the cloud, avoiding the network transmission of the complete graph. Multiple candidate reconstruction schemes generated by the cloud-based large language model are distributed to the edge servers in a structured data format, and each edge server performs digital twin simulation evaluation in parallel. Different edge servers are responsible for the compatibility simulation and time simulation of different schemes, and the main edge node makes the decision after joint evaluation. This parallel evaluation mechanism significantly shortens the total evaluation time. In addition, during the entry of the mobile welding robot, its edge computing unit reports its position and status in real time and updates the global cost map in collaboration with the fixed edge nodes in the workshop to ensure that the entry path does not conflict with the operation path of other robots. The above mechanism fully verifies the effectiveness of the attribution vector and large language model graph reconstruction mechanism in handling complex constraint conflicts.
[0072] Example 3 This embodiment describes a scenario in a large warehouse environment where multiple Automated Guided Vehicles (AGVs) collaboratively transport large goods. The warehouse is equipped with several heavy-duty AGVs, each featuring a LiDAR-based simultaneous localization and mapping system, providing high positioning accuracy. The task requires moving multiple heavy-duty containers from the east area of the warehouse to the packing station in the west area. The weight of the containers varies over a wide range. The user instruction is to move the heavy-duty containers from the east area to the west area packing station, minimizing overlapping transport paths and completing the task quickly.
[0073] This embodiment constructs a dense edge computing network, deploying edge computing access points in different areas of the warehouse. Each access point covers a certain radius and is interconnected via a high-speed wireless network. Each automated guided vehicle (AGV) is equipped with an onboard lightweight edge computing unit, supporting real-time processing of LiDAR point clouds and local path planning. The onboard edge unit and the regional edge access points form a two-tiered collaborative architecture. The regional edge access points are responsible for the collaborative scheduling of multiple vehicles within their respective areas, while global optimization tasks are handled by the cloud server. A distributed consensus protocol is used between edge access points to synchronize obstacle maps and vehicle status, resulting in short synchronization cycles and minimal map inconsistencies.
[0074] The global planning agent generates a flexible strategy optimization graph containing multiple nodes. Each cargo box corresponds to a visual positioning node, a forklift node, a path planning and handling node, and a placement node. Dependencies ensure that handling can only be performed after forklifting is completed, and placement can only be performed after handling is completed. Timing coordination constraints are set at path intersections to avoid collisions. The dynamic task scheduling agent generates an initial scheduling scheme based on resource function vectors and vehicle status data streams. Resource function vectors include dimensions such as load weight, LiDAR coverage, and remaining battery state of charge. The vehicle status data stream displays the battery state of charge distribution of each automated guided vehicle (AGV). The initial scheduling allocates handling tasks to multiple AGVs. Strategy nodes contain specific path corridors and time window constraints, combined into an execution task data set. During local action generation, due to the high dynamism of the warehouse environment, including personnel movement and temporary pallet stacking, the calculated planning suitability score is below the threshold. Therefore, each AGV adopts an attached... Figure 3 The ReAct interactive exploration engine shown on the right has a high LiDAR data refresh rate and a reasonable maximum number of exploration steps for path replanning.
[0075] During execution, an automated guided vehicle (AGV) reported a path congestion anomaly in the warehouse aisle, which was linked to the corresponding cargo handling path segment. The system immediately retrieved the AGV's multimodal data stream, including LiDAR point cloud, wheel speed sensor data, inertial measurement unit (INS) data, and front-facing camera images. This data was compared with a high-precision digital twin environment model, which showed an appropriate update frequency. Deviation analysis revealed sufficient aisle width in the digital twin environment, but the actual point cloud detected temporarily stacked pallets occupying one side of the aisle, reducing the effective width. The AGV's required passage width exceeded the actual effective width, resulting in a significant deviation. A structured state divergence model was used for causal decoupling, and a lightweight machine learning model was used to output an attribution vector. This model was trained on a large number of historical congestion events, demonstrating high classification accuracy. The attribution vector included the obstacle type being a static temporary object with the largest contribution, mobility being negative, and the conflict constraint being a aisle width limitation, indicating insufficient current width.
[0076] The attribution vector is input into a large language model, which, combined with a policy optimization knowledge base containing multiple path anomaly handling schemes, makes a decision. The large language model performs local path reconstruction without changing the global scheduling. The reconstructed flexible policy optimization graph adds a detour exploration subtask to the current handling node, with the exploration distance and allowable time increase within reasonable ranges, and fine-tunes the start time of subsequent cargo handling. After receiving the new graph, the Automated Guided Vehicle's ReAct engine plans a new detour route via other channels in a very short time based on the local cost map. The new path length is slightly increased, and the detour time increase is within constraints. The detour is executed successfully, and the cargo is placed within the specified time.
[0077] This embodiment includes an exception escalation mechanism. If the number of failed detour attempts reaches a predetermined limit, the exception is escalated. The automated guided vehicle reports an impassable event for the current area to the scheduling layer, and the event communication module associates it with the relevant cargo container handling strategy node. The dynamic task scheduling agent then processes the report according to the attached... Figure 6 The second level of hierarchical constraint relaxation is initiated, downgrading the path non-overlap preference constraint and allowing other automated guided vehicles (AGVs) to partially overlap with the new path of the malfunctioning vehicle during subsequent transport. The solver quickly redistributes the transport tasks to idle vehicles, forming a local rescheduling scheme. If this scheme fails, the third level of global replanning is triggered. The global planning agent regenerates the complete graph and redistributes the affected tasks.
[0078] Edge collaborative computing is crucial in this embodiment. The onboard edge computing unit processes LiDAR point cloud data in real time, performing congestion detection and effective width calculation locally. It only uploads the attribution vector to the regional edge access point. The regional edge access point aggregates congestion information from multiple vehicles and reports it uniformly to the cloud-based large model, avoiding network congestion caused by each vehicle communicating independently with the cloud. Detour path planning is completed independently by the onboard edge unit, significantly reducing response time compared to cloud inference. When the number of detour failures accumulates, the onboard edge unit of the faulty vehicle collaborates with the regional edge access point to determine an anomaly escalation threshold. The regional edge access point actively queries the status of surrounding vehicles and quickly matches idle vehicles for relay transport. Furthermore, multiple automated guided vehicles (AGVs) exchange real-time locations and path segments through the edge access point, employing a distributed conflict detection mechanism to adjust the passage order before path intersections, avoiding deadlocks. This distributed mechanism significantly reduces the computational load on the central scheduler, distributing the risk of single-point failures to each edge node.
[0079] This embodiment underwent multiple Monte Carlo simulation tests. The proportion of local ReAct detours triggered by dynamic environmental changes was moderate, the increase in average detour success time was within an acceptable range, and the deadlock rate caused by path congestion was zero. The obstacle classification accuracy of the attribution vector was high, the average response time of local rescheduling was short, and the average time of global replanning was reasonable. The total time for the system to complete all container handling in a dynamic environment was minimal compared to the static ideal scheduling, proving that the multi-layer recovery mechanism and the digital twin bias-driven reconstruction graph method combined with the edge collaborative architecture can effectively ensure the high completion rate and strong adaptability of dynamic warehousing operations. The edge collaborative network had extremely high availability during the test, and the recovery time of a single communication interruption was extremely short, meeting the reliability requirements of warehousing and logistics scenarios.
[0080] The above embodiments are merely illustrative examples and are not intended to limit the implementation. Those skilled in the art will recognize that other variations or modifications can be made based on the above description. It is neither necessary nor possible to exhaustively list all possible implementations. However, obvious variations or modifications derived therefrom are still within the scope of protection of this invention.
Claims
1. A multi-agent collaborative dynamic workflow control and scheduling method based on edge environments, characterized in that, Includes the following steps: Multiple edge nodes are deployed in an edge computing network, and each edge node is connected to a physical device and interconnected through a high-speed network. Receive natural language task instructions input by the user through edge nodes; The global planning agent generates an abstract task sequence containing multiple nodes with the support of a cloud-based large language model. The abstract task sequence is decomposed and initially generated by retrieving relevant context through vector retrieval, constructing prompt words to input into the large language model, and using a rule validator for multi-dimensional verification and feedback. The dynamic task scheduling agent performs resource allocation and conflict management based on the abstract task sequence, understands user needs through the intent parsing layer, and transforms the intent into a mathematical model through the dynamic modeling layer; The dynamic modeling layer uses a large language model for incremental updates and maintains the consistency of variables and constraints through a runtime symbol library. The code execution layer uses a high-performance mathematical programming solver to solve the mathematical model and runs the solution code in a sandbox execution environment; If the solver returns an infeasible state, it will be handled according to the three-level exception recovery mechanism.
2. The method according to claim 1, characterized in that, The global planning agent generates an abstract task sequence, which further includes: Domain knowledge documents are vector-encoded and then stored in a vector database; Upon receiving a natural language instruction, the system retrieves the relevant reference context from the vector database and loads the set of compliant actions. Construct prompt words containing the natural language instructions, reference context, and set of compliant actions, and input the prompt words into the large language model; the large language model performs task decomposition and outputs a preliminary task graph, and the rule validator performs format, loop, and action legality checks on the preliminary task graph; If the validation succeeds, the final abstract workflow is output; if the validation fails, an error feedback message is generated and a replanning is triggered. The vector retrieval and rule verification processes are assisted by lightweight modules on the edge nodes.
3. The method according to claim 1, characterized in that, The dynamic task scheduling agent further includes the following aspects in allocating resources: The intent parsing layer includes a RAG vector retrieval module, a parameter weight parsing module, a semantic routing module, and a rescheduling module; The dynamic modeling layer includes an LLM incremental modeling module, a runtime symbol library module, a code model integration module, and a constraint relaxation module; The LLM incremental modeling module extracts current context information, obtains a symbolic snapshot of the current model, organizes the information and symbolic snapshot into logical triples, and inputs them into the large language model to generate incremental patches. After being verified in a security sandbox, the incremental patches are used to update the model matrix.
4. The method according to claim 1, characterized in that, Local action generation further includes: For deterministic scenarios where the rules are clear and the state is fully known, the planning domain definition language pattern is adopted. After symbolic solving, semantic translation and syntax verification at the edge nodes, the action plan is directly output. For uncertain scenarios with dynamic environmental changes and incomplete information, the ReAct dynamic exploration mode is adopted, which interacts with the environment through edge nodes and gradually approaches the target through iterative cycles. Based on the planning suitability score calculated from the edge nodes, the system dynamically switches between PDDL mode and ReAct mode.
5. The method according to claim 1, characterized in that, The three-level anomaly recovery mechanism includes the following steps: The first level is the semantic reflection level, which uses irreducible and infeasible subset analysis to locate the minimum set of conflicting constraints and retains all user intent by adjusting the model expression or repairing logical conflicts. The second level is the constraint relaxation level. When the semantic reflection level cannot resolve the conflict, a suboptimal relaxation solution is obtained by relaxing non-critical constraints or introducing penalty variables. The third level is the baseline rollback level. If the first two levels fail, all incremental patches are discarded, and the system rolls back to a pre-defined baseline scheme that only guarantees physical security.
6. The method according to claim 1, characterized in that, Also includes: When a device malfunction occurs during task execution, the edge node immediately performs preliminary deviation identification locally, and retrieves real-time data of the current device and digital twin model data for comparison; Causal decoupling is achieved through a structured state divergence model, generating attribution vectors that include primary and secondary causes; The attribution vectors are uploaded to a large language model in the cloud and combined with a policy optimization knowledge base for reasoning, so as to reconstruct a flexible policy optimization graph for decision-making. The reconstructed graph is distributed from the cloud to each edge node to enable edge-end collaborative decision-making; Edge nodes synchronize status information through a publish-subscribe mechanism to ensure coordinated actions among multiple devices.
7. The method according to claim 1, characterized in that, Also includes: Based on the initial scheduling requirements and equipment capabilities, the resource function vectors of each task node are extracted; Constraints that meet the preset conditions are directly mapped to model weights through the parameter fast channel; Personalized constraints are input into the incremental slow channel, processed by the dynamic modeling layer, and incremental constraint code is generated. The parameter fast channel operates entirely locally on the edge node, while the incremental slow channel only invokes the cloud-based large language model when needed.
