Multi-agent dynamic task scheduling method and system based on large language model

Abstract

The present application relates to the technical field of policy optimization, in particular to a multi-agent dynamic task scheduling method and system based on a large language model, which decomposes task instructions into a flexible policy optimization graph by using a large language model, and combines a constraint solver and a real-time state of a robot to perform resource allocation and plan generation; in task execution, the multi-modal perception data of the robot are compared with the digital twin model to perform checking and deviation analysis, and abnormal responses are traced back; a structured state divergence model is used to perform causal attribution on the deviation, and the quantitative result is fed back to the large language model, so that the large language model reconstructs the flexible policy optimization graph based on a policy optimization knowledge base, and a closed loop iteration is formed. The present application constructs a closed loop feedback system from perception, decision-making to optimization, and can accurately identify environmental uncertainty and optimize task strategies.

Description

Technical Field

[0001] This invention relates to the field of strategy optimization technology, specifically to a multi-agent dynamic task scheduling method and system based on a large language model. Background Technology

[0002] As core programmable execution units in automated production and intelligent services, the collaborative program control and system-level task scheduling of multi-robot robots are key metrics for evaluating the overall performance of computing systems. Currently, collaborative control and scheduling technologies for robot swarms mainly fall into two categories: one is based on a pre-defined work process and workflow management system architecture, using offline programming to create a fixed set of static task allocation and execution scripts managed by a central controller; the other employs a scheme based on real-time sensor data streams and distributed algorithms. The robot analyzes environmental data, combines motion planning and strategy optimization algorithms to dynamically generate optimal control strategies, and solves problems such as collision-free paths in collaborative operations through numerical simulations. These technologies constitute the basic architecture of current distributed robot program control systems.

[0003] However, the inherent defects in the system architecture and algorithm models of the aforementioned existing technologies become increasingly prominent when facing increasingly complex and highly dynamic environments. The systems suffer from severe deficiencies in dynamic strategy optimization and anomaly handling capabilities, and limitations exist at the human-machine interface and front-end data parsing mechanism levels. Existing systems cannot parse and compile complex instructions issued by operators in natural language, which contain intricate logic and objectives. This results in any non-standard task requiring cumbersome manual coding, leading to low scheduling efficiency for the robot's logistics handling tasks. The pre-defined static program logic cannot cope with sudden situations caused by asynchronous events or runtime state changes. For example, in robot logistics handling, when material data is abnormal, material supply is interrupted, or a robot unit experiences a hardware failure, the system lacks real-time strategy optimization capabilities and cannot autonomously generate a system-level fault-tolerant and recovery process to reallocate computational tasks.

[0004] Therefore, this invention proposes a multi-agent dynamic task scheduling method and system based on a large language model. Summary of the Invention

[0005] The purpose of this invention is to provide a multi-agent dynamic task scheduling method and system based on a large language model to solve the problems mentioned in the background art.

[0006] To achieve the above objectives, the present invention provides the following technical solution: A multi-agent dynamic task scheduling method based on a large language model includes: semantic decomposition of task instructions of a work robot using a large language model, and construction of a flexible strategy optimization graph containing task nodes, task parameters and dependencies. Based on the task parameters in the flexible strategy optimization graph, a resource function vector is generated. The resource function vector is input into the constraint solver to perform scheduling constraint parsing and generate scheduling constraints. Based on the scheduling constraints and the state data stream of the robot, resource allocation is optimized and task nodes are executed to generate strategy nodes. Based on the dependency relationship, the strategy nodes are combined into a set of execution task data. The system receives abnormal response data transmitted back from the task execution data set by the robot, and then associates the abnormal response data back to the strategy node in the task execution data set. The strategy node drives the multimodal perception data stream of the robot and the digital twin model to perform verification and deviation analysis, and generates deviation data. A structured state divergence model is constructed to decouple the deviation data from cause and effect and vectorize the attribution, generating an attribution vector containing constraint conflicts. The attribution vector is then input into a large language model, and the strategy is optimized based on the strategy optimization knowledge base. The flexible strategy optimization graph is then reconstructed, and the task execution of the robot in the next round is carried out through the reconstructed flexible strategy optimization graph.

[0007] Preferably, the specific generation process of the flexible strategy optimization graph is as follows: the large language model receives the task instructions from the work robot, performs natural language processing and semantic parsing, extracts task elements including task description, input and output requirements of task resources and constraints, and defines the task elements as task nodes of the flexible strategy optimization graph. The task nodes are associated with corresponding task parameters including execution time, resource requirements and priority; the logical relationship between task nodes is defined as directed dependency edges, weight parameters are added to the directed dependency edges, and the flexible strategy optimization graph is generated.

[0008] Preferably, the specific generation process of the resource function vector and scheduling constraints is as follows: extracting task parameters from the flexible strategy optimization graph, standardizing the task parameters to generate a multi-dimensional feature vector, and matching and mapping the multi-dimensional feature vector with the capability vectors of each robot in the available resource library of the operating robot; the matching and mapping determines the matching degree score by calculating the Euclidean distance between the multi-dimensional feature vector and each robot capability vector, and constructing the resource function vector based on the matching degree score; inputting the resource function vector into a constraint solver to perform scheduling constraint parsing and generate scheduling constraints; the constraint conditions of the constraint solver include resource allocation upper limit, time window limit, and priority rules.

[0009] Preferably, the resource allocation optimization specifically includes: receiving the scheduling constraints and the state data stream of the working robot; performing real-time aggregation and feature extraction on the state data stream to generate a dynamic resource state vector, including current load, available capacity, and performance indicators; fusing and matching the dynamic resource state vector with the scheduling constraints based on a resource allocation scheme to generate a resource allocation matrix, wherein the resource allocation scheme is calculated and generated using a reinforcement learning model, and the reward function of the reinforcement learning model has resource utilization and execution efficiency as optimization objectives; generating an execution task data set containing specific execution steps based on the resource allocation matrix, wherein the execution task data set consists of a series of policy nodes, monitoring the execution process of the policy nodes, wherein the policy nodes include robot allocation, resource allocation, execution path, and adjustment parameters; and performing topological sorting and combination of the policy nodes according to the directed dependency edges in the flexible policy optimization graph to generate the execution task data set, including serialization steps and distribution instructions, and distributing it to the working robot through a network interface.

[0010] Preferably, the process of back-associating the abnormal response data to the strategy nodes in the execution task data set specifically includes: receiving abnormal response data returned by the work robot in the execution task data set, the abnormal response data including error code, abnormal description, timestamp, and execution context; performing log parsing and structured extraction on the abnormal response data to generate an abnormal event vector, the abnormal event vector including abnormal type, impact range, and correlation indicators; using a timestamp-based matching algorithm to match and map the abnormal event vector with the execution logs of the strategy nodes, back-associating the abnormal response data to the strategy nodes in the execution task data set; adding abnormal tags to the strategy nodes, adjusting weight parameters, and recording conflict history, and generating a correlation report.

[0011] Preferably, the verification and deviation analysis process specifically includes: driving the acquisition of multimodal perception data streams of the operation robot through the strategy nodes in the associated report. The multimodal perception data streams include visual image information, LiDAR point clouds, and sensor readings. These data streams are synchronized with the digital twin model through timestamp alignment and data stream fusion. Multi-level verification is performed on the synchronized data, including feature extraction, state matching, and calculation of the deviation between the multimodal perception data streams and the predicted state of the digital twin model, generating deviation values. Spectral analysis techniques are used to analyze the deviation values, including identifying anomalies caused by positional shifts, behavioral inconsistencies, and detectable external interference, generating deviation analysis results. A multi-dimensional deviation analysis framework is constructed to decompose and classify the deviation analysis results, including spatiotemporal deviations, modal deviations, and global deviations, generating deviation data.

[0012] Preferably, the specific process of causal decoupling and vectorized attribution, and the specific process of generating attribution vectors, include: constructing a structured state divergence model, receiving bias data, performing causal decoupling on the bias data through a causal inference model, and separating causal features; based on the causal features, performing vectorized attribution using an attribution algorithm to generate attribution vectors; the dimension of the attribution vector corresponds one-to-one with a preset root cause fault, and its element value is the posterior probability of the root cause fault.

[0013] Preferably, the process of optimizing the strategy and reconstructing the flexible strategy optimization graph specifically includes: inputting the attribution vector into a large language model; evaluating and optimizing the strategy based on a strategy optimization knowledge base to generate an optimization scheme; the strategy optimization knowledge base contains historical execution log data; and the optimization scheme includes optimized task parameter adjustment schemes and dependency correction suggestions; based on the optimization scheme, reconstructing the flexible strategy optimization graph using the large language model, including updating the parameters of task nodes and adjusting the weights of directed dependency edges; and applying the reconstructed flexible strategy optimization graph to the task execution of the next round of the work robot to form a closed-loop dynamic scheduling iteration.

[0014] A multi-agent dynamic task scheduling system based on a large language model includes: Semantic decomposition module: Used to perform semantic decomposition of task instructions for the operation robot through a large language model, and to construct a flexible strategy optimization graph that includes task nodes, task parameters and dependencies; The plan generation module is used to generate resource function vectors based on task parameters in the flexible strategy optimization graph, input the resource function vectors into the constraint solver to perform scheduling constraint parsing, generate scheduling constraints, optimize resource allocation based on scheduling constraints and the state data stream of the robot, execute task nodes, generate strategy nodes, and combine strategy nodes into an execution task data set based on the dependency relationship. Execution and Feedback Module: Used to receive abnormal response data returned by the robot in the task execution data set, and to correlate the abnormal response data back to the strategy node in the task execution data set; Deviation Analysis Module: Used to verify and analyze the multimodal perception data stream and digital twin model of the robot driven by the strategy node, and generate deviation data; Causal Attribution Module: Used to build a structured state divergence model to decouple and vectorize the deviation data, and generate an attribution vector that includes constraint conflicts; Strategy optimization module: It is used to input the attribution vector into the large language model, optimize the strategy based on the strategy optimization knowledge base, and reconstruct the flexible strategy optimization graph. The next round of task execution by the robot is carried out through the reconstructed flexible strategy optimization graph.

[0015] Compared with the prior art, the beneficial effects of the present invention are as follows: 1. This invention lays the foundation for flexible task planning by initially decomposing the task using a large language model and constructing a flexible strategy optimization graph. When the robot encounters unexpected situations while performing a task, the system can capture deviations in real time through a digital twin model and multimodal perception data streams, accurately locate the root cause of the problem using a structured state divergence model, and finally dynamically reconstruct the task graph through closed-loop feedback. This design allows the system to no longer rely on preset rigid rules and can quickly adjust its strategy in constantly changing environments, significantly enhancing the adaptability and anti-interference capability of the entire multi-agent system in robotic logistics handling scenarios.

[0016] 2. Traditional scheduling methods often make reactive adjustments after anomalies occur. This invention, however, through verification and deviation analysis, combined with causal decoupling and vectorized attribution, enables a deeper understanding of the causal chain behind deviations, rather than merely addressing surface phenomena. The quantified attribution results are input into a large language model for policy optimization, allowing the system to learn from historical deviations and conflicts and proactively adjust future task planning based on a policy optimization knowledge base. This represents a leap from simple fault recovery to in-depth causal analysis and predictive optimization, thereby continuously improving the global optimality of the scheduling strategy.

[0017] 3. This invention analyzes resource function vectors using a constraint solver to generate scheduling constraints and introduces a reinforcement learning model into resource allocation to maximize resource utilization and execution efficiency. During execution, if a deviation occurs, the system can quickly analyze the deviation using a digital twin, perform accurate causal attribution, and then rapidly reconstruct an optimized execution strategy. This series of automated and intelligent closed-loop processes significantly reduces time and resource waste caused by anomalies, conflicts, and waiting, ensuring close and efficient collaboration among multiple robots, thereby maximizing overall operational efficiency in dynamic robotic logistics handling scenarios. Attached Figure Description

[0018] Figure 1 This is a flowchart illustrating the steps of a multi-agent dynamic task scheduling method based on a large language model. Figure 2 This is a flowchart illustrating a multi-agent dynamic task scheduling method based on a large language model. Figure 3 This is a system architecture diagram of a multi-agent dynamic task scheduling system based on a large language model. Detailed Implementation

[0019] The technical solutions of the embodiments 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] Please see Figures 1 to 3 This invention provides a multi-agent dynamic task scheduling method based on a large language model, the technical solution of which is as follows: A multi-agent dynamic task scheduling method based on a large language model, referring to Figure 1 The specific implementation steps of the method proposed in this invention include: S1. Semantically decompose the task instructions of the operation robot using a large language model, and construct a flexible strategy optimization graph that includes task nodes, task parameters and dependencies.

[0021] S2. Based on the task parameters in the flexible strategy optimization graph, generate a resource function vector, input the resource function vector into the constraint solver to perform scheduling constraint parsing, generate scheduling constraints, optimize resource allocation based on scheduling constraints and the state data stream of the robot, execute task nodes, generate strategy nodes, and combine strategy nodes into an execution task data set based on the dependency relationship.

[0022] S3. Receive the abnormal response data returned by the work robot in the task execution data set, and associate the abnormal response data with the strategy node in the task execution data set.

[0023] S4. Verify and analyze the multimodal perception data stream and digital twin model of the robot driven by the strategy node, generate deviation data, construct a structured state divergence model to decouple the deviation data from cause and effect and vectorize the attribution, and generate an attribution vector containing constraint conflicts.

[0024] S5. Input the attribution vector into the large language model, optimize the strategy based on the strategy optimization knowledge base, and reconstruct the flexible strategy optimization graph. Then, execute the task of the robot in the next round of operation through the reconstructed flexible strategy optimization graph.

[0025] Example 1:

[0026] This embodiment provides a specific application of a multi-agent dynamic task scheduling method based on a large language model, referring to... Figure 2 Specifically: Furthermore, semantic decomposition of the task instructions of the work robot is performed using a large language model to construct a flexible strategy optimization graph containing task nodes, task parameters, and dependencies. Corresponding to step S1 above, the specific process is as follows: The flexible strategy optimization graph involved in this step is a data structure used for representing and optimizing robotic logistics handling tasks. It is generated from unstructured task instructions by a large language model and includes task nodes, task parameters, and weighted directed dependency edges. This graph serves as the core carrier for dynamic scheduling, anomaly association, and strategy optimization and reconstruction, supporting flexible adjustment and optimization throughout the entire task execution cycle.

[0027] The specific construction process of the flexible strategy optimization graph is as follows: When an urgent task is received—to retrieve one box each of high-precision sensors from area A-07 and microcontrollers from area C-03 and transport them to the S-01 assembly line within 30 minutes—a large language model performs natural language processing and semantic parsing on the urgent task, extracting the task elements: Task description: material handling; Task resources: high-precision sensors, microcontrollers, and a robot; Input / output requirements: starting point is areas A-07 and C-03, ending point is the S-01 assembly line; Constraints: "urgent" (high priority), "complete within 30 minutes" (time window). These elements are defined as task nodes in the graph (going to area A-07, grabbing sensors, etc.) and associated with task parameters (such as estimated duration, high priority). The logical and temporal relationships between nodes (grabbing before transporting) are defined as directed dependency edges and weighted, ultimately generating the flexible strategy optimization graph for this task. Unlike traditional static task chains, the dependency edges in the flexible policy optimization graph are weighted. The weights represent the tightness of the association, time interval requirements, or failure propagation probability, giving the flexible policy optimization graph the ability to dynamically adjust. In this embodiment, the data structure of the flexible policy optimization graph can be defined as a directed acyclic graph, as follows: Task node: A structure or object containing fields: Node ID: A unique identifier; Node type: Enumeration type (e.g., "navigation", "grab", "place"); Parameters: Dictionary (e.g., {"target location": [x, y, z], "item ID": "sensor A"}); Status: Enumeration type (e.g., "Pending", "In Progress", "Completed", "Failed"); Required resources: Dictionary (e.g., {"load": 5.0", "end effector type": "gripper"}).

[0028] Directed dependency edge: A structure or object containing fields: Starting node ID; Target node ID; Edge type: enumerated type (such as "time series" dependency, "resource" dependency); Weight: Floating-point number.

[0029] The quantification logic of the weights is as follows: When the large language model is guided to output the expected content through prompting engineering, and it can recognize mandatory temporal words such as "must" and "then", the weight is assigned a value of 1.0; when it recognizes weak temporal words such as "suggest" and "it is best to first", the weight is assigned a value of 0.5. For more complex logic, such as "either A or B is acceptable", parallel optional dependency edges are generated in the graph; for "A is completed within 5 minutes after B", a time window constraint parameter (such as {type: "delay", maximum number of seconds: 300}) is added to the dependency edge.

[0030] The flexible strategy optimization graph completes the transformation from task instructions to precise machine execution. It structures and visualizes complex tasks, providing a unified data foundation for subsequent algorithm processing. Its flexibility is reflected in its dynamic reconfigurability. When anomalies occur during execution or environmental changes occur, the execution plan is not canceled. New optimization strategies can be quickly generated simply by adjusting the node parameters or edge weights in the graph, greatly enhancing the adaptability and robustness of the entire task scheduling method.

[0031] Furthermore, based on the task parameters in the flexible strategy optimization graph, a resource function vector is generated. This resource function vector is then input into a constraint solver for scheduling constraint parsing, generating scheduling constraints. Based on these scheduling constraints and the robot's state data stream, resource allocation is optimized, and task nodes are executed, generating strategy nodes. Based on the dependencies, these strategy nodes are combined into a task execution data set. Corresponding to step S2 above, the specific process is as follows: The resource function vector (RFV) involved in this step is a multidimensional data representation used to describe the matching relationship between task requirements and the capabilities of the robot. It is constructed by standardizing task parameters, combining the robot's available resource library, and using a matching score calculated using the Euclidean distance algorithm. The RMV serves as a quantitative input for constraint solving and resource optimization allocation.

[0032] The specific generation process of the resource function vector is as follows: Standardized task parameters (resource requirements, priority, execution time) are extracted from each task node of the flexible strategy optimization graph. These parameters are combined into a multi-dimensional feature vector. An available resource library for the robot is used, containing the capabilities, status, and specifications of each robot. The matching relationship is calculated by comparing the multi-dimensional feature vector of the task parameters (i.e., the task requirement vector) with the robot capability vectors of various resources in the robot resource library. The matching process uses the Euclidean distance algorithm. The specific calculation process includes: a task requirement is encoded as a vector V_task = (required load (kg), required navigation accuracy (mm), one-hot encoding of the required end effector type). A robot capability is encoded as V_robot = (maximum load (kg), self-navigation accuracy (mm), one-hot encoding of the end effector type). Before computation, all numerical dimensions are subjected to max-min normalization. Then, the Euclidean distance between V_task and each V_robot vector is calculated. The calculated Euclidean distance (or its reciprocal) between the task and all available robots is used as the matching score to construct a resource function vector. This resource function vector is a set containing all robots and their corresponding matching scores. This vector will be used in the reward function of the subsequent reinforcement learning model as one of the decision-making references. It is a structured vector whose dimensions clearly define the resource type (transportation, grasping), capacity (maximum load), and dynamic adjustment capability (speed adjustable). The resource function vector is then input into a specialized constraint solver. In this embodiment, the constraint solver is a mixed-integer linear programming modeler that receives the vector and parses it into the following mathematical model to define the constraint boundary of the subsequent reinforcement learning model: The constraints include: Unique task assignment constraint: For any task i, ensure that the task is executed only once; Robot resource constraints: For any robot j and time k, at any point in time (time k), the total amount of resources used by all tasks allocated to a certain robot (robot j) must never exceed the resource limit that the robot itself possesses. Graph dependency constraint: If there is an edge from node m to node n in the graph, indicating that m is a prerequisite task for n, then the start execution time of node n must be greater than or equal to the end execution time of node m to ensure the execution order.

[0033] The modeler ultimately outputs this set of analytically derived mathematical scheduling constraints as input for the next stage.

[0034] By vectorizing and matching task requirements with robot capabilities, the modeler achieves refined and quantitative management of resource scheduling, thereby enabling the assessment of the matching degree between tasks and resources. The constraint solver automatically generates optimal scheduling constraints for complex scenarios, ensuring the rationality, efficiency, and compliance of resource allocation and avoiding resource conflicts and waste.

[0035] The system receives scheduling constraints generated by the constraint solver and simultaneously monitors the state data streams of all operating robots. These data streams are aggregated and feature extracted in real time to form a dynamic resource state vector. This vector precisely describes the current state of each robot, including its current load, remaining available capacity, and core performance indicators (battery power, operating efficiency). The dynamic resource state vector is then fused and matched with the static scheduling constraints. This matching process is not a simple linear allocation but is accomplished through a resource allocation scheme based on a reinforcement learning model. The model's reward function aims to maximize both resource utilization and task execution efficiency, and also uses the generated resource function vector (i.e., the matching score) as a key reward term. Through calculation, the model generates an optimal resource allocation matrix that clearly indicates which robot should execute which task node at the current time.

[0036] The resource allocation scheme based on the reinforcement learning model is defined by the following model structure and operating mechanism: State space S: Defined as a structured state representation, this vector contains all the key information needed to make scheduling decisions. Specifically, it includes the states of all n operating robots and the states of all m pending task nodes in the system. A graph neural network is used to encode the dynamically changing set of robots and tasks to generate fixed-dimensional state embedding vectors. Action space A is defined as a discrete set of actions. For each idle robot j and each task i in an unassigned state, there exists a possible action a, representing the assignment of task i to robot j. The entire action space consists of all valid combinations.

[0037] Reward function R: At each decision time step t, the system calculates a scalar reward based on the execution result. .

[0038] The formula is: .in, This represents the number of tasks completed within this step. Total idle time for all robots; Total energy consumption; This is a penalty for exceeding the time limit. , , , These are the corresponding parameter weights.

[0039] This embodiment employs a deep Q-network algorithm. A neural network is constructed to approximate the optimal action value function. During runtime, the system inputs the current state vector S into the trained deep Q-network, which outputs the Q-value for each possible action a. The system selects the action with the highest Q-value for execution, thereby achieving optimal dynamic resource allocation.

[0040] Based on the resource allocation matrix, task nodes are issued for execution. During execution, strategy nodes are continuously monitored and generated. These are data units containing complete execution information, including specific robot allocation, resource allocation schemes, planned execution paths, and necessary dynamic adjustment parameters. Finally, based on the directed dependency edges defined in the flexible strategy optimization graph, all generated strategy nodes are topologically sorted and combined to form an ordered and complete set of execution task data. This set contains serialized execution steps and distribution instructions, which are distributed to the corresponding task robots via interfaces such as wireless networks.

[0041] This method represents a leap from static planning to dynamic optimization. By combining reinforcement learning models and real-time state data, it dynamically and intelligently allocates resources in a constantly changing environment, ensuring that the allocation scheme always approaches the global optimum. This not only improves resource utilization and task execution efficiency but also greatly enhances robustness and adaptability in the face of unforeseen circumstances.

[0042] Resource function vectors transform the complex, heterogeneous resource matching problem into an efficient vector space computation problem. This approach not only significantly improves the efficiency and accuracy of matching but, more importantly, enables refined and quantitative management of resources. It allows scheduling methods to move beyond simply determining availability; instead, it assesses which resource is most suitable and provides standardized, high-quality input data for subsequent constraint solvers, thereby ensuring the global optimality of resource allocation schemes.

[0043] Furthermore, the abnormal response data transmitted back by the robot from the task execution data set is received, and the abnormal response data is back-associated to the policy node in the task execution data set. Corresponding to step S3 above, the specific process is as follows: The real-time status data stream of the robot is compared with the expected status generated by the digital twin model, and a two-level triggering logic is used to determine whether to generate abnormal response data and initiate the subsequent closed-loop feedback process: Level 1 Trigger (Explicit Fault): When the module receives an execution status report from the robot containing explicit error codes (e.g., path planning failure code, sensor offline code, motor overload code), the system classifies the report as a high-priority abnormal response and directly associates it with the currently executing strategy node.

[0044] Level 2 Trigger (Implicit Deviation): The module calculates deviation values ​​for a set of key performance indicators in real time, including but not limited to: relative speed error equals the absolute value of the difference between the actual speed and the expected speed of the digital twin model divided by the expected speed of the digital twin model; task node execution time error equals the actual time spent minus the expected time of the digital twin model; abnormal drive motor current equals the actual current consumed minus the rated current. The module embeds a set of configurable rules to identify performance degradation. For example, in this embodiment, the trigger rule can be set as follows: when the relative speed error is greater than 20% for more than 30 seconds, or when the task node execution time error is greater than 120 seconds, the system classifies this performance failure as an abnormal response. At this time, the module automatically generates an internal anomaly report containing detailed deviation data, associates it with the corresponding strategy node, and thus formally initiates the subsequent verification and in-depth deviation analysis process.

[0045] When a robot encounters a problem (path congestion, failed cargo grabbing) during task execution and sends back abnormal response data, the abnormal data reverse association process is initiated. The received raw abnormal response data typically includes error codes, human-readable abnormal descriptions, precise timestamps, and execution context information at the time of the abnormality. First, this data undergoes log parsing and structured extraction, transforming it into a standardized abnormal event vector. This vector clearly defines the type of abnormality (hardware failure, path conflict), the estimated impact range, and the associated key performance indicator (task delay time). Then, a timestamp-based matching algorithm is used to match and map this abnormal event vector with the execution logs of each policy node. Specifically, the implementation steps of the timestamp-based matching algorithm include: to achieve accurate attribution of abnormal response data, the algorithm first filters all policy nodes assigned to the robot from the task dataset as candidates based on the robot identifier contained in the abnormal data. Next, the algorithm matches the timestamp of the abnormal data with the execution time window of each policy node in the candidate set. If an anomaly timestamp falls within the time window of only one policy node, it is directly associated. If it falls within multiple overlapping time windows, it is preferentially associated with the lowest-level node with the shortest time window to ensure accuracy. For anomalies not within the time window of any currently executing node, the algorithm associates them with the previous completed policy node with the closest timestamp, thus completing the reverse association and attribution of the anomaly. Subsequently, the policy node located by the algorithm is processed, an anomaly label is added to it, its weight parameters in the graph are dynamically adjusted (lowering its priority or increasing its estimated risk), and detailed information about the conflict is recorded in the conflict history log, ultimately generating a complete association report.

[0046] A precise and automated fault tracing mechanism has been established. It can quickly locate the root cause of problems from massive amounts of execution data, linking ambiguous anomalies to specific execution strategies, thus avoiding the inefficiency and errors of manual troubleshooting. By marking and recording problem nodes, accurate data input is provided for subsequent deviation analysis and strategy optimization.

[0047] Furthermore, the multimodal perception data stream of the robot driven by the strategy node is verified and deviation analysis is performed on the digital twin model to generate deviation data. A structured state divergence model is constructed to decouple the deviation data from its causal state and perform vectorized attribution, generating an attribution vector containing constraint conflicts. Corresponding to step S4 above, the specific process is as follows: In this step, the digital twin model includes a physics simulation engine that uses the robot's kinematic and dynamic parameters. A state prediction module receives policy nodes from step S2, such as path and velocity. This module simulates the execution of these policies and outputs a predicted state sequence, including expected coordinates, motor current, and battery level. This output sequence serves as the benchmark for comparison during subsequent deviation analysis.

[0048] Based on the strategy nodes marked in the correlation report, a comprehensive multimodal perception data stream acquisition is performed on the corresponding robot. The acquired data stream is multi-source, including high-resolution robot visual image information, LiDAR point cloud data for 3D environment perception, and readings from various internal sensors (joint angles, motor currents). Through precise timestamp alignment and data stream fusion technology, this real-time perception data from the physical world is subjected to multi-level verification with the digital twin model. This includes extracting key features for comparison, matching the state parameters of both, and calculating the deviation between the real-world state represented by the multimodal perception data stream and the theoretical state predicted by the digital twin model, generating a quantified deviation value. Further spectral analysis techniques (such as short-time Fourier transform or wavelet analysis) are used to perform in-depth deviation analysis on the deviation value. Specifically, the deviation value is treated as a one-dimensional time series signal. This spectral analysis technique is used to analyze the frequency domain characteristics of the deviation signal, thereby distinguishing between global deviations (such as encoder cumulative error, manifested as significant differences in low-frequency components) and local, high-frequency deviations caused by detectable external interference (such as transient obstacle avoidance, manifested as instantaneous bursts of high-frequency components). Through this analysis, it is possible to accurately identify whether the deviation is due to positional shifts, inconsistencies in behavioral patterns, or anomalies caused by externally detected interference, generating detailed deviation analysis results. Finally, a multi-dimensional deviation analysis framework is used to further decompose and classify these results, such as into spatiotemporal deviations, modal deviations (visual anomalies only), or global deviations, ultimately generating structured, multi-dimensional deviation data.

[0049] By using digital twin technology, we compare the actual performance in the physical world with the model's predicted state in the virtual world for quantitative analysis. This method verifies the authenticity of anomalies, reveals how they occur from multiple dimensions, and provides multimodal data support for subsequent causal attribution.

[0050] The Structured State Divergence Model is an analytical model used for deep diagnostics of the root causes of task execution anomalies. It receives deviation data between physical world perception data and digital twin models, and through causal decoupling and vectorized attribution techniques, it separates and quantifies the core causal factors that lead to state divergence, ultimately generating attribution vectors containing constraint conflicts that can be understood by large language models.

[0051] The construction of the structured state divergence model is an expert modeling step completed offline before system deployment. In this embodiment, for the robot, the specific construction process is as follows (construction of the dynamic Bayesian network): Observation node (O): corresponds to the deviation data generated in the previous stage of S4, such as (Speed ​​deviation) (Current deviation); State node (S): corresponds to the readings of internal sensors of the robot, such as... (Perceived load) (Battery voltage); Root cause nodes (R): Based on the failure mode and impact analysis report and historical maintenance logs of the operating robot, all known physical faults (such as battery aging, motor overheating, sensor drift) and logical conflicts (such as path deadlock, resource preemption) are extracted as a set of root cause nodes R, such as... (Bearing wear) (Battery low).

[0052] The process of constructing causal relationships (i.e., directed edges): Based on the robot's physical model, kinematics, and dynamics equations, deterministic causal relationships (directed edges) are established between nodes R, S, and O, such as... (This indicates that insufficient battery power causes a drop in voltage, which in turn leads to speed deviation.) (This indicates that bearing wear leads to increased sensing load, which in turn causes an increase in current, ultimately resulting in speed deviation.)

[0053] Parameter training: By actively injecting the root cause faults defined in step S4 into the digital twin model, simulations are run to generate paired datasets of (R,S,O) in batches; using this simulation dataset and a small number of real fault logs collected, the conditional probability table of the dynamic Bayesian network is trained with the maximum likelihood estimation method, thereby completing the construction of the entire model.

[0054] A pre-constructed structured state divergence model is employed. This model receives the deviation data generated in the previous stage and first uses causal inference techniques (such as dynamic Bayesian networks) to decouple it causally. This process aims to remove pseudo-correspondences among numerous related factors and separate truly causal independent features. For the two phenomena of battery voltage drop and robot slow movement, the model can decouple the former as the cause and the latter as the effect, establishing a causal chain. Specifically, the model in this embodiment is a dynamic Bayesian network. The nodes of the network represent state variables and fault events. The directed edges between nodes represent causal relationships pre-defined based on physical laws or empirical knowledge. When deviation data is received, it is input into the network as evidence. The model first uses a dynamic Bayesian network to decouple it causally. After separating the causal features, the model performs vectorized attribution using a confidence propagation algorithm. This process quantitatively assigns the responsibility or contribution of the deviation to each causal feature, that is, updates and outputs the posterior probability of each unobserved node, generating a physical fault posterior probability vector (i.e., attribution vector).

[0055] The attribution vector contains constraint conflicts. This attribution vector is a highly condensed data package that includes a quantitative indicator of the conflict (conflict severity score) and a projection vector of the conflict (indicating the direction of the problem). The dimensions of the attribution vector correspond one-to-one with the root cause faults (such as low battery, overload, and path slippage) pre-defined in the structured state divergence model, and each element in the vector is the posterior probability of the corresponding fault inferred by the dynamic Bayesian network.

[0056] The system then evaluates the confidence level of the attribution vector: Known Fault (High Confidence): If a root cause fault (such as...) is present in the attribution vector output by the structured state divergence model... If the posterior probability of a fault is significantly higher than a preset threshold (e.g., > 0.8), the system determines it as a known fault and passes this high-confidence attribution vector to the policy optimization module of S5.

[0057] The structured state divergence model represents an intelligent upgrade from correlation analysis to causal inference. It can penetrate the surface of a problem, accurately pinpoint the root cause of state divergences, and translate complex causal relationships into an easily understood and processed attribution vector using a large language model, greatly improving the depth and accuracy of problem diagnosis.

[0058] Furthermore, the attribution vector is input into the large language model, and policy optimization is performed based on the policy optimization knowledge base to generate a reconstructed flexible policy optimization graph. The next round of task execution by the robot is carried out through the reconstructed flexible policy optimization graph, corresponding to step S5 above. The specific process is as follows: The attribution vector containing constraint conflicts generated in the previous step is input into the large language model. After receiving this structured problem report, the large language model will call the policy optimization knowledge base to perform multiple rounds of policy evaluation and optimization. To solve the cold start problem in the early stages of system deployment, this knowledge base can be pre-configured with a set of baseline optimization rules based on expert experience or simulation testing. After the system is running, this knowledge base is the result of the large language model's long-term learning and contains all historical task execution log data. Based on the conflict root causes revealed by the attribution vector, the large language model will reason and associate in the knowledge base to generate a comprehensive optimization scheme. This scheme may include suggestions for adjusting certain task parameters (increasing the estimated duration of task X by 15%) and suggestions for correcting inter-task dependencies (removing the strong dependency of task Y on task Z and changing it to a weak dependency). The specific technical process of policy optimization knowledge base interaction and optimization scheme generation includes: Knowledge Base Structure and Retrieval Mechanism: In this embodiment, the knowledge base is a vector database. Each historical anomaly and its successful solution are encoded and stored as a data entry, which contains the anomaly's attribution vector and the corresponding plain text solution description. When a new attribution vector... When a known fault (identified by S4) is input, the system employs a retrieval-enhanced generation process. First, the system constructs a contextual attribution vector, which includes not only... It also concatenates key features (e.g., anomaly type) from the S3 anomaly event vector; key quantitative indicators (e.g., speed deviation value) from the S4 deviation data; and task parameters (e.g., task type, priority) from the current policy node. The K-nearest neighbor algorithm is executed in the vector database, using the context attribution vector as the query vector, to retrieve the k (e.g., k=5) most similar attribution vectors of historical anomalies and their corresponding solution texts.

[0059] Inference based on a large language model generated by retrieval enhancement: The system combines the retrieved k historical cases (as successful experiences) with the current new question (feature vector). This is injected into a pre-defined prompt template. The prompt template guides the large language model: "You are a multi-agent task scheduling expert. The current system has encountered a problem, and the feature vector is..." (Insert k typical historical cases) Analyze the reasons for their success or failure, and provide a complete and feasible improvement plan for the current problem. The large language model integrates background information and case information, and through reasoning, provides a completely new optimization solution.

[0060] The large language model parses the novel optimization scheme into a new set of constraints or adjustment parameters for the reinforcement learning model's reward function applied to the next round of tasks. When the next round of task execution begins, the plan generation module in S2 calls the reinforcement learning model. Guided by the new constraints and reward function output by the large language model, it recalculates and generates the optimal resource allocation matrix and task execution data set. The large language model is responsible for high-level policy and logic adjustments, while the reinforcement learning model is responsible for solving low-level real-time numerical optimization within the new policy boundaries, ensuring unified control and forming a closed-loop dynamic scheduling iteration.

[0061] The specific process of closed-loop dynamic scheduling iteration includes: Optimization scheme execution and monitoring: The system executes the reconstructed flexible strategy optimization map, and the deviation analysis module continuously monitors the deviation data related to previous anomalies.

[0062] Success verification: The system sets verification rules, for example: if the deviation value represented by the same attribution vector does not exceed the preset threshold again in the next N time periods (N is configurable, such as 10 periods), the system determines that the optimization scheme previously generated by the large language model is a successful solution.

[0063] Knowledge base update: After successful verification, the system will automatically use the attribution vector that caused the anomaly as the key (query index) and the optimization scheme generated by the large language model (e.g., text containing optimized task parameter adjustment schemes and dependency correction suggestions) as the value, encode and store it in the vector database of the strategy optimization knowledge base for retrieval when encountering similar problems in the future.

[0064] This method constructs a complete closed-loop feedback loop for learning from errors. It not only identifies and analyzes problems, but also automatically and intelligently solves them and optimizes future decisions. By continuously reconstructing the flexible strategy optimization graph, the large language model can continuously accumulate experience and evolve, making it increasingly efficient and robust when facing similar problems.

[0065] This invention achieves highly intelligent and adaptive task scheduling for operational robots by constructing a complete closed loop from semantic understanding to execution feedback and then to strategy optimization. The flexible strategy optimization graph constructed through semantic decomposition using a large language model can accurately capture task intent and complex constraints, far surpassing traditional template-based or fixed-rule scheduling methods, thus improving the flexibility and accuracy of task scheduling. Combining digital twins, multimodal perception, and causal inference, this method not only detects execution deviations but also delves into their root causes, achieving in-depth fault diagnosis and root cause tracing. By feeding attribution vectors back to the large language model for strategy optimization and graph reconstruction, the large language model can learn from each anomaly, continuously improving its decision-making level and adaptability to dynamic environments, thereby becoming more efficient and robust in long-term operation, endowing the large language model with self-learning and evolutionary capabilities.

[0066] Example 2:

[0067] This embodiment is a specific application of a multi-agent dynamic task scheduling system based on a large language model, referring to... Figure 3 Specifically, in the material center of a large-scale intelligent manufacturing plant, the system received a high-priority urgent task. The task was to take one box each of high-precision sensors from area A-07 and microcontrollers from area C-03 and transport them to the S-01 assembly line, which had to be completed within 30 minutes.

[0068] Upon receiving the aforementioned urgent task instruction, the semantic decomposition module rapidly parses the instruction using its large language model, identifying it as a complex task involving multi-point pickup and single-point delivery. It decomposes the task into task nodes: (1) Navigate to area A07; (2) Grab the sensor; (3) Navigate to area C-03; (4) Grab the controller; (5) Navigate to assembly line S-01; (6) Unload all goods. Simultaneously, it adds the constraint of "completing within 30 minutes" to the top layer of the entire task chain. The system constructs a "flexible strategy optimization graph" containing explicit dependencies and global time constraints as the initial blueprint for task execution.

[0069] The plan generation module receives the flexible strategy optimization map generated by the semantic decomposition module. The module analyzes the map and assesses available resources. Based on the map data and the robot's current state, it calculates the optimal solution for the fastest single robot (let's say AGV-007) to execute all nodes sequentially, satisfying the 30-minute time limit, with an estimated total time of 25 minutes and a 5-minute redundancy. Therefore, it generates a complete action plan for AGV-007. The module then issues instructions containing the complete path and action sequence to AGV-007.

[0070] The execution and feedback module receives real-time status data streams from AGV-007 during task execution. AGV-007 successfully reaches zone A-07 and retrieves the sensor cargo box, but en route to zone C-03, the module's monitoring system detects an anomaly: AGV-007's actual operating speed consistently falls below its theoretical maximum speed for that section of the route by 20%, despite not reporting any error codes. While this performance degradation doesn't trigger a hard fault, the system predicts it will increase the total task time by approximately 6 minutes, exceeding the 30-minute deadline. The module records this latent performance issue as an anomaly response data and precisely correlates it to the "navigate to zone C-03" strategy node. The execution and feedback module generates a correlation report, identifying the strategy node responsible for the performance deviation and triggering in-depth analysis.

[0071] The deviation analysis module received a correlation report from the execution and feedback module. Then, the deviation analysis module compared the AGV-007's real-time perception data with the digital twin model. The results showed that there were no obstacles on the actual path, and the digital twin model's predicted state also indicated no obstacles, so the external environment was not the cause of the deceleration. Next, the module further checked the AGV-007's internal sensor data and found that the drive motor's power consumption was higher than usual, but the battery voltage was normal. Finally, the deviation analysis module generated deviation data, indicating that the problem lay within the robot, caused by reduced efficiency of the power system, rather than external factors.

[0072] The causal attribution module receives deviation data from the deviation analysis module. The structured state divergence model within the module analyzes the data to investigate the cause. Based on existing physics knowledge and past fault records, the model first rules out battery issues, then establishes a causal relationship between the phenomena of "high power consumption" and "low speed," finally determining the root cause to be "excessive robot load or increased resistance in the transmission system." Combining task information, the structured state divergence model identifies the cause as "internal mechanical failure of the robot." The module generates an attribution vector containing the root cause, with the core information being: (Conflict type: task timeliness risk; Attribution: AGV-007's own performance degradation).

[0073] The strategy optimization module received the attribution vector from the causal attribution module.

[0074] The large language model determined that AGV-007 was no longer able to complete the urgent task, so it queried the strategy optimization knowledge base and initiated a dynamic task replanning and resource reallocation plan.

[0075] The large language model devised a new optimal solution: AGV-007 immediately stopped moving forward, waited safely at its current position, and reported its accurate coordinates. Simultaneously, AGV-008, the closest and in the best condition, was assigned to perform the new task. AGV-008 will first go to AGV-007's location, take the sensor cargo box from it, then continue to area C-03 to retrieve the controller, and finally transport both boxes of goods together to the S-01 assembly line.

[0076] Based on this optimization scheme, the system updated the flexible strategy optimization map, transferring all subsequent task nodes originally assigned to AGV-007 to AGV-008. The strategy optimization module generated a reconstructed flexible strategy optimization map and issued new instructions to AGV-008. Through this seamless task handover, the system successfully avoided task failures caused by a single robot malfunction. Ultimately, all materials were accurately delivered within 28 minutes, ensuring continuous production.

[0077] This modular system design makes the logic of the entire complex system clear and the responsibilities well-defined. Each module is responsible for solving only one core problem, which facilitates development, testing, maintenance, and future expansion. This highly cohesive and loosely coupled structure ensures that the entire dynamic scheduling system can operate stably and efficiently, and is easily expandable.

[0078] 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 multi-agent dynamic task scheduling method based on a large language model, characterized by: Semantic decomposition of task instructions for the work robot is performed using a large language model to construct a flexible strategy optimization graph that includes task nodes, task parameters, and dependencies. Based on the task parameters in the flexible strategy optimization graph, a resource function vector is generated. The resource function vector is input into the constraint solver to perform scheduling constraint parsing and generate scheduling constraints. Based on the scheduling constraints and the state data stream of the robot, resource allocation is optimized and task nodes are executed to generate strategy nodes. Based on the dependency relationship, the strategy nodes are combined into a set of execution task data. The resource allocation optimization specifically includes: receiving the scheduling constraints and the state data stream of the working robot; performing real-time aggregation and feature extraction on the state data stream to generate a dynamic resource state vector, including current load, available capacity, and performance indicators; fusing and matching the dynamic resource state vector with the scheduling constraints based on a resource allocation scheme to generate a resource allocation matrix, wherein the resource allocation scheme is calculated and generated using a reinforcement learning model, and the reward function of the reinforcement learning model has resource utilization and execution efficiency as optimization objectives; generating an execution task data set containing specific execution steps based on the resource allocation matrix, wherein the execution task data set consists of a series of policy nodes, monitoring the execution process of the policy nodes, wherein the policy nodes include robot allocation, resource allocation, execution path, and adjustment parameters; and performing topological sorting and combination of the policy nodes according to the directed dependency edges in the flexible policy optimization graph to generate the execution task data set, including serialization steps and distribution instructions, and distributing it to the working robot through a network interface. The system receives abnormal response data transmitted back from the task execution data set by the robot, and then associates the abnormal response data back to the strategy node in the task execution data set. The strategy node drives the multimodal perception data stream of the robot and the digital twin model to perform verification and deviation analysis, and generates deviation data. A structured state divergence model is constructed to decouple the deviation data from cause and effect and vectorize the attribution, generating an attribution vector containing constraint conflicts. The attribution vector is then input into a large language model, and the strategy is optimized based on the strategy optimization knowledge base. The flexible strategy optimization graph is then reconstructed, and the task execution of the robot in the next round is carried out through the reconstructed flexible strategy optimization graph.

2. The multi-agent dynamic task scheduling method based on a large language model according to claim 1, characterized in that, The specific process for generating the flexible strategy optimization map is as follows: The large language model receives task instructions from the work robot, performs natural language processing and semantic parsing, extracts task elements including task description, input and output requirements of task resources, and constraints, and defines the task elements as task nodes in a flexible strategy optimization graph. The task nodes are associated with corresponding task parameters including execution time, resource requirements, and priority. The logical relationships between task nodes are defined as directed dependency edges, and weight parameters are added to the directed dependency edges to generate a flexible strategy optimization graph.

3. The multi-agent dynamic task scheduling method based on a large language model according to claim 1, characterized in that, The specific process for generating the resource function vector and scheduling constraints is as follows: Task parameters are extracted from the flexible strategy optimization graph, standardized, and multi-dimensional feature vectors are generated. These multi-dimensional feature vectors are then matched and mapped with the capability vectors of each robot in the available resource library of the task robot. The matching mapping determines the matching score by calculating the Euclidean distance between the multi-dimensional feature vectors and each robot capability vector. The resource function vector is constructed based on the matching score. The resource function vector is then input into a constraint solver for scheduling constraint parsing to generate scheduling constraints. The constraints of the constraint solver include resource allocation upper limits, time window limits, and priority rules.

4. The multi-agent dynamic task scheduling method based on a large language model according to claim 1, characterized in that, The process of back-associating the abnormal response data to the policy nodes in the execution task data set specifically includes: The system receives abnormal response data transmitted back from the task execution data set by the work robot. The abnormal response data includes error codes, abnormal descriptions, timestamps, and execution context. The system performs log parsing and structured extraction on the abnormal response data to generate abnormal event vectors. The abnormal event vectors include abnormal type, impact range, and related indicators. Based on the abnormal event vectors and the execution logs of the policy nodes, a timestamp-based matching algorithm is used to perform matching and mapping. The abnormal response data is then back-linked to the policy nodes in the task execution data set. Abnormal tags are added to the policy nodes, weight parameters are adjusted, and conflict history is recorded to generate a correlation report.

5. The multi-agent dynamic task scheduling method based on a large language model according to claim 4, characterized in that, The verification and deviation analysis process specifically includes: The multimodal perception data stream of the robot is acquired through the strategy nodes in the associated report. This multimodal perception data stream includes visual image information, LiDAR point cloud, and sensor readings. Through timestamp alignment and data stream fusion, the multimodal perception data stream is synchronized with the digital twin model. Multi-level verification is performed on the synchronized data, including feature extraction, state matching, and calculation of the deviation between the multimodal perception data stream and the predicted state of the digital twin model, generating deviation values. Spectral analysis techniques are used to analyze these deviation values, including identifying anomalies caused by positional shifts, behavioral inconsistencies, and detectable external interference, generating deviation analysis results. A multi-dimensional deviation analysis framework is constructed to decompose and classify the deviation analysis results, including spatiotemporal deviation, modal deviation, and global deviation, generating deviation data.

6. The multi-agent dynamic task scheduling method based on a large language model according to claim 1, characterized in that, The specific process of performing causal decoupling and vectorized attribution, and the specific process of generating attribution vectors, include: A structured state divergence model is constructed to receive deviation data. The deviation data is causally decoupled using a causal inference model to separate causal features. Based on the causal features, an attribution algorithm is used to perform vectorized attribution and generate attribution vectors. The dimensions of the attribution vectors correspond one-to-one with the preset root cause faults, and the element values ​​are the posterior probabilities of the root cause faults.

7. The multi-agent dynamic task scheduling method based on a large language model according to claim 1, characterized in that, The process of optimizing the strategy and reconstructing the flexible strategy optimization graph specifically includes: The attribution vector is input into a large language model, and an optimization scheme is generated based on a policy optimization knowledge base containing historical execution log data. The optimization scheme includes optimized task parameter adjustment schemes and dependency relationship correction suggestions. Based on the optimization scheme, a flexible policy optimization graph is reconstructed using the large language model, including updating the parameters of task nodes and adjusting the weights of directed dependency edges. The reconstructed flexible policy optimization graph is applied to the task execution of the next round of the operation robot, forming a closed-loop dynamic scheduling iteration.

8. A multi-agent dynamic task scheduling system based on a large language model, characterized in that, include: Semantic decomposition module: Used to perform semantic decomposition of task instructions for the operation robot through a large language model, and to construct a flexible strategy optimization graph that includes task nodes, task parameters and dependencies; The plan generation module is used to generate resource function vectors based on task parameters in the flexible strategy optimization graph, input the resource function vectors into the constraint solver to perform scheduling constraint parsing, generate scheduling constraints, optimize resource allocation based on scheduling constraints and the state data stream of the robot, execute task nodes, generate strategy nodes, and combine strategy nodes into an execution task data set based on the dependency relationship. The resource allocation optimization specifically includes: receiving the scheduling constraints and the state data stream of the working robot; performing real-time aggregation and feature extraction on the state data stream to generate a dynamic resource state vector, including current load, available capacity, and performance indicators; fusing and matching the dynamic resource state vector with the scheduling constraints based on a resource allocation scheme to generate a resource allocation matrix, wherein the resource allocation scheme is calculated and generated using a reinforcement learning model, and the reward function of the reinforcement learning model has resource utilization and execution efficiency as optimization objectives; generating an execution task data set containing specific execution steps based on the resource allocation matrix, wherein the execution task data set consists of a series of policy nodes, monitoring the execution process of the policy nodes, wherein the policy nodes include robot allocation, resource allocation, execution path, and adjustment parameters; and performing topological sorting and combination of the policy nodes according to the directed dependency edges in the flexible policy optimization graph to generate the execution task data set, including serialization steps and distribution instructions, and distributing it to the working robot through a network interface. Execution and Feedback Module: Used to receive abnormal response data returned by the robot in the task execution data set, and to correlate the abnormal response data back to the strategy node in the task execution data set; Deviation Analysis Module: Used to verify and analyze the multimodal perception data stream and digital twin model of the robot driven by the strategy node, and generate deviation data; Causal Attribution Module: Used to build a structured state divergence model to decouple and vectorize the deviation data, and generate an attribution vector that includes constraint conflicts; Strategy optimization module: It is used to input the attribution vector into the large language model, optimize the strategy based on the strategy optimization knowledge base, and reconstruct the flexible strategy optimization graph. The next round of task execution by the robot is carried out through the reconstructed flexible strategy optimization graph.

Images