Multi-agent adaptive cooperation method, system, device and storage medium

Abstract

The application provides a multi-agent adaptive cooperation method, system, device and storage medium, and relates to the technical field of agent cooperation and scheduling. In view of the problems in the prior art, such as static task allocation, difficulty in adapting to dynamic changes of the field state, long time consumption of re-planning, and insufficient real-time performance and robustness, a pre-generated slicing scheme of a target task is first acquired at an edge coordination node side, the slicing scheme is converted into a constraint solving model facing the current environment in combination with real-time sensing states, and fast solving is completed within a limited time window, so that executable task instructions are formed and are sent to corresponding physical or virtual agents for execution. The scheme can quickly instantiate an existing task scheme into an execution result conforming to the current constraints, improve the matching degree of task allocation and field conditions, reduce scheduling lag and execution mismatch risk, and improve the real-time adaptability, continuous cooperation capability and overall operation stability of multi-agent cooperation.

Description

Technical Field

[0001] This application relates to the field of intelligent agent cooperation and scheduling technology, specifically to a multi-agent adaptive cooperation method, system, device and storage medium. Background Technology

[0002] Collaborative cooperation among multiple intelligent agents (such as logistics robots, autonomous vehicles, and code generation agents) has wide-ranging applications in smart factories, intelligent logistics, and automated software development. Especially in high real-time applications such as physical delivery and automated code compilation, the system needs to complete task allocation and execution response within milliseconds, placing extremely high demands on collaboration efficiency and reliability.

[0003] Existing multi-agent collaboration methods typically employ centralized task allocation or inter-agent negotiation mechanisms. For example, a central platform assigns tasks to agents based on global information, and the agents execute instructions accordingly; or task division and conflict resolution are achieved through communication and negotiation between agents. While these methods can achieve multi-agent collaboration to some extent, in dynamically changing environments, when device states change, temporary obstacles occur, or new tasks are inserted, the central platform needs to recalculate the global data, and the negotiation mechanism relies on multiple information exchanges. Both methods struggle to achieve rapid response and dynamic adaptation within strict time windows.

[0004] Therefore, how to achieve rapid, accurate, and adaptive collaboration among multiple agents in high real-time scenarios while ensuring reasonable task allocation has become a pressing technical problem to be solved in this field. Summary of the Invention

[0005] This application provides a multi-agent adaptive cooperation method, system, device, and storage medium to solve the above-mentioned technical problems.

[0006] In a first aspect, this application provides a multi-agent adaptive cooperation method applied to edge coordination nodes, the method comprising:

[0007] Obtain a pre-slicing scheme package generated for the target task; wherein, the pre-slicing scheme package is used to indicate the initial allocation information and initial constraints of the task slices decomposed from the target task;

[0008] Based on real-time sensing information, the pre-sliced ​​scheme package is instantiated into the current constraint satisfaction problem model;

[0009] The constraint solver is invoked to solve the constraint satisfaction problem model within a preset time window, and an executable task slice instruction set is output.

[0010] The task slice instruction set is sent to the corresponding intelligent agent for execution.

[0011] In one possible implementation, obtaining the pre-slice scheme package generated for the target task includes:

[0012] Receive pre-slicing scheme packages from nodes of the multi-agent collaboration platform;

[0013] The multi-agent collaborative platform node is used to construct a constraint satisfaction problem model and perform simulation deduction based on the structured task objective, global capability library, and environmental digital twin model of the target task, so as to generate the pre-sliced ​​solution package; the global capability library includes the capability vectors of each agent, and the environmental digital twin model is used to simulate the application scenario to which the target task belongs.

[0014] In one possible implementation, the real-time sensing information includes at least one of the following: real-time state information of agents within a preset jurisdiction, environmental change information, and task change information; the step of instantiating the pre-sliced ​​scheme package into the current constraint satisfaction problem model based on the real-time sensing information includes:

[0015] Based on the real-time status information, update the set of candidate agents for the allocation object variables of the task slices in the constraint-satisfying problem model.

[0016] Based on the environmental change information and / or the task change information, the variable domain and constraint conditions of the constraint satisfaction problem model are dynamically updated to obtain the current constraint satisfaction problem model.

[0017] In one possible implementation, the constraint solver solves the constraint satisfaction problem model within a preset time window and outputs an executable task slice instruction set, including:

[0018] The constraint satisfaction problem model is input into the constraint solver for solution.

[0019] If a feasible solution that satisfies all constraints is found within a preset time window, a task slice instruction set is generated based on the feasible solution.

[0020] If no feasible solution is found within the preset time window, a rollback mechanism is triggered, and a task slicing instruction set is generated based on the backup schemes contained in the pre-slicing scheme package.

[0021] In one possible implementation, generating the task slice instruction set based on the feasible solution includes:

[0022] Before the preset time window ends, according to the preset optimization objective, the optimal solution is found among the feasible solutions, and a task slice instruction set is generated based on the optimal solution.

[0023] In one possible implementation, the method further includes:

[0024] During the execution of the task slice instruction set, the execution status of the intelligent agent is monitored;

[0025] When an abnormal event is detected, it triggers multiple other intelligent agents within a preset jurisdiction to report the observation data of the abnormal intelligent agent;

[0026] The observed data are processed for consensus based on a weighted consensus protocol to determine the collaborative diagnostic results.

[0027] Based on the results of the collaborative diagnosis, graded abnormality handling is performed.

[0028] In one possible implementation, the step of performing graded anomaly processing based on the collaborative diagnostic results includes:

[0029] According to the anomaly handling strategy library, match the anomaly level and handling strategy corresponding to the collaborative diagnosis result, and execute the matched handling strategy;

[0030] The anomaly handling strategy library includes predefined anomaly levels and corresponding handling strategies according to at least one of the following dimensions: security, reliability, and performance. The anomaly levels include L1, L2, and L3. If it is L1, a preset recovery procedure or fine-tuning parameters is executed. If it is L2, the relevant task flow is frozen, and the constraint solver is called to perform local dynamic slice replanning, generate a recovery plan, and issue it. If it is L3, an emergency stop command is sent and an alarm is triggered.

[0031] In one possible implementation, the method further includes:

[0032] The results of anomaly handling and newly emerging anomaly patterns are reported to the multi-agent collaboration platform nodes to update the anomaly handling strategy library.

[0033] Secondly, embodiments of this application provide a multi-agent adaptive cooperation method, applied to a multi-agent cooperation platform node, the method comprising:

[0034] Obtain the structured task objectives of the target task to be processed;

[0035] Based on the structured task objective, global capability library, and environmental digital twin model, a constraint satisfaction problem model is constructed and simulated to generate a pre-slice solution package for the target task. The global capability library includes capability vectors of each agent, and the environmental digital twin model is used to simulate the application scenario to which the target task belongs. The pre-slice solution package is used to indicate the initial allocation information and initial constraints of the task slices decomposed from the target task.

[0036] The pre-slicing scheme package is distributed to the edge coordination node.

[0037] In one possible implementation, obtaining the structured task target of the target task to be processed includes:

[0038] The user input requirements are parsed using a large language model to generate a structured task objective for the target task.

[0039] In one possible implementation, the step of constructing a constraint satisfaction problem model and performing simulation deduction based on the structured task objective, the global capability library, and the environmental digital twin model, to generate a pre-sliced ​​solution package for the target task, includes:

[0040] Based on the structured task objectives, global capability library, and environmental digital twin model, a constraint satisfaction problem model is constructed; wherein, the constraint satisfaction problem model includes decision variables and constraints related to the task slice;

[0041] Using Monte Carlo tree search or offline reinforcement learning algorithms, the constraint satisfaction problem model is simulated and deduced in the digital twin model of the environment to generate a pre-sliced ​​solution package for the target task.

[0042] In one possible implementation, the method further includes at least one of the following:

[0043] Construct an environmental digital twin model of the application scenario to which the target task belongs, and update the environmental digital twin model according to changes in the application scenario;

[0044] A unified capability model is performed on each registered agent, and the function of each agent is quantified into a multi-dimensional capability vector to form a global capability library.

[0045] Based on at least one of the security, reliability, and performance dimensions, a three-level anomaly level (L1, L2, and L3) and corresponding handling strategies are predefined to construct an anomaly handling strategy library.

[0046] Thirdly, embodiments of this application provide a multi-agent adaptive cooperative system, including:

[0047] Multi-agent collaborative platform nodes, used for the second aspect and / or various possible methods of the second aspect as described above;

[0048] Edge coordination nodes are used to perform the first aspect and / or various possible methods of the first aspect as described above;

[0049] The intelligent agent execution node is used to receive and execute the task slice instruction set issued by the edge coordination node.

[0050] Fourthly, embodiments of this application provide an electronic device, including: a memory and a processor;

[0051] The memory stores computer-executed instructions;

[0052] The processor executes computer execution instructions stored in the memory, causing the processor to perform various possible implementations of the first and / or second aspects described above.

[0053] Fifthly, embodiments of this application provide a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, are used to implement various possible implementations of the first and / or second aspects described above.

[0054] The beneficial effects of this application are:

[0055] The multi-agent adaptive collaboration method, system, device, and storage medium provided in this application acquire a pre-slicing scheme package generated for the target task and combine it with real-time perception information to transform the pre-slicing scheme package into a currently solvable constraint satisfaction problem model. It can output an executable task slice instruction set within a preset time window and send it to the corresponding agent for execution. This enables the slice allocation and execution process of the target task to be dynamically adjusted according to changes in the field state, thereby improving the real-time adaptability, anomaly response efficiency, and overall collaboration stability of multi-agent collaboration. Attached Figure Description

[0056] Figure 1 This application provides an embodiment of a multi-agent adaptive cooperative system architecture diagram.

[0057] Figure 2 A flowchart illustrating a multi-agent adaptive cooperation method applied to nodes of a multi-agent cooperative platform, provided in an embodiment of this application;

[0058] Figure 3 This is a schematic diagram of the internal structure of a node in a multi-agent collaborative platform provided in an embodiment of this application;

[0059] Figure 4 A flowchart illustrating a multi-agent adaptive cooperation method applied to an edge coordination node, provided in an embodiment of this application;

[0060] Figure 5 A schematic diagram of the interaction process of a multi-agent adaptive cooperation method provided in an embodiment of this application;

[0061] Figure 6 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. Detailed Implementation

[0062] The embodiments of this application will be described below with reference to the accompanying drawings and preferred embodiments. Those skilled in the art can easily understand other advantages and effects of this application from the content disclosed in this specification. This application can also be implemented or applied through other different specific embodiments, and various details in this specification can also be modified or changed based on different viewpoints and applications without departing from the spirit of this application. It should be understood that the preferred embodiments are only for illustrating this application and are not intended to limit the scope of protection of this application.

[0063] It should be noted that the illustrations provided in the following embodiments are only schematic representations of the basic concept of this application. Therefore, the drawings only show the components related to this application and are not drawn according to the actual number, shape and size of the components in the actual implementation. In the actual implementation, the form, quantity and proportion of each component can be arbitrarily changed, and the layout of the components may also be more complex.

[0064] Multi-agent collaboration technology is widely used in high real-time business scenarios such as intelligent manufacturing, logistics scheduling, multi-robot collaborative operations, and the collaborative linkage between physical execution units and software services. In such scenarios, the system typically includes not only physical agents that perform tasks such as handling, assembly, inspection, or delivery, but also virtual agents that perform functions such as order parsing, inventory calculation, path management, resource scheduling, and status monitoring. The two need to form a closed-loop linkage around the same objective task. Taking a logistics warehousing scenario as an example, the handling robots, sorting equipment, and conveying units in the warehouse, together with the upper-level order system, inventory service, and scheduling service, constitute a collaborative system. The system needs to break down the overall task into multiple executable links according to the order objective and complete the scheduling execution by combining equipment location, operating status, path access conditions, and processing priorities. Since the business objects include both physical entities and virtual services, and the on-site environment has obvious dynamics, this technology field places high demands on the millisecond-level real-time adaptability of task allocation, the ability to handle multiple constraints uniformly, and the ability to continuously collaborate and self-heal under abnormal conditions. In particular, it is necessary to quickly adjust the allocation results according to the latest status before the task is completed or even during execution to avoid the spread of local changes to a decrease in overall collaboration efficiency.

[0065] Existing multi-agent collaboration solutions typically revolve around task decomposition, centralized scheduling, or negotiated collaboration. The basic idea is that the upper-level system first generates the target task based on business requirements, then breaks down the target task into several sub-tasks according to preset rules, experience templates, or static scheduling models, and assigns the sub-tasks to pre-selected execution agents. From a working principle perspective, these solutions mostly rely on fixed processes or static constraints to complete the decomposition and allocation. The system's handling of constraints such as device capabilities, path limitations, service load, and task dependencies is often fixed in the task generation stage, and the subsequent execution process largely proceeds according to a predetermined plan. However, in dynamic environments where physical and virtual agents coexist, such solutions have significant limitations: First, while large language models can generate subtask descriptions, they cannot translate them into executable instructions for the agents—lacking specific information on "who does it and when," thus creating a gap between "semantics and action." Second, centralized scheduling easily becomes a performance bottleneck and suffers from single points of failure, while purely distributed negotiation is time-consuming, struggles to guarantee global constraints, and cannot balance global optimization with millisecond-level real-time response. Third, the anomaly handling mechanism is crude, failing to classify anomalies or utilize redundant observation resources among multiple agents for collaborative diagnosis; uniform handling of all anomalies leads to inefficiency or insufficient security response. Especially in scenarios requiring millisecond-level or near-real-time responses, existing solutions cannot balance global optimization with millisecond-level real-time response, resulting in low collaborative efficiency and poor robustness.

[0066] In view of this, and to address the aforementioned technical problems, this application provides a multi-agent adaptive collaborative framework based on unified capability modeling and dynamic constraint solving. The technical concept is as follows: On the platform side, the capabilities of agents are abstracted into standardized multi-dimensional capability vectors, a global capability library is constructed, and combined with an environmental digital twin model, pre-sliced ​​solution packages are generated through constraint satisfaction problem (CSP) modeling and simulation. On the edge side, after receiving the pre-sliced ​​solution package, real-time perception information is injected to instantiate it into a dynamic constraint satisfaction problem, and a lightweight constraint solver is invoked to output executable instructions containing agent identifiers and execution time constraints within a millisecond-level time window. During execution, a weighted consensus protocol is used for multi-agent collaborative diagnosis, and anomalies are handled hierarchically. This forms a closed loop of "perception-planning-decision-execution-learning," achieving precise allocation of task slices and adaptive recovery from anomalies. This application breaks through the reliance of traditional methods on static rules or centralized decision-making, reduces the response delay and execution mismatch caused by the disconnect between static allocation and the actual state, realizes deterministic transformation from semantic tasks to executable instructions and adaptive robust cooperation in high real-time scenarios, and also improves the real-time adaptability and overall operational stability in the multi-agent cooperation process.

[0067] The technical solution of this application and how the technical solution of this application solves the above-mentioned technical problems are described in detail below with specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments. The embodiments of this application will now be described with reference to the accompanying drawings.

[0068] It should be noted that this application applies to high real-time scenarios such as intelligent manufacturing, logistics and transportation, automated software development (e.g., collaboration between code agents and test agents), and multi-robot collaborative operations. For example, in logistics and warehousing scenarios, physical intelligent agents (e.g., AGV handling robots) need to collaborate with virtual intelligent agents (e.g., inventory management systems) to complete tasks such as goods sorting, path planning, and dynamic scheduling; in automated software development, code generation agents and test agents need to respond to changes in requirements and adjust their collaboration strategies in real time.

[0069] It should be further noted that, in the description of this application, the terms "multi-agent collaboration platform node," "platform node," "platform-side node," "multi-agent collaboration platform system," and "task parsing layer" all refer to the same logical entity deployed in the cloud or central data center, responsible for global pre-planning and knowledge management; the terms "edge coordination node," "edge coordinator," "edge coordinator module," "edge-side node," and "edge processing layer" all refer to the same logical entity deployed near the task site, responsible for local real-time decision-making; the terms "agent execution node," "agent execution module," "agent," "terminal execution layer," and "executor" all refer to the physical or virtual intelligent agent that actually executes the task slice. The different terms mentioned above mainly differ due to different descriptive perspectives (system structure, module functions, signaling interaction, etc.) and the way the figures are labeled, but their technical meanings and entity correspondences remain consistent in this application. The modules can communicate through standardized data interfaces, and different physical deployment forms do not affect the definition of functional logic. The embodiments of this application do not limit the specific names used.

[0070] The multi-agent adaptive collaboration system of this application includes at least: a multi-agent collaboration platform node (responsible for global pre-planning and knowledge management, including the construction and maintenance of capability libraries, digital twin models, and anomaly handling strategy libraries, as well as the generation of pre-slice solution packages), an edge coordination node (responsible for local real-time decision-making, including real-time perception information fusion, constraint satisfaction problem instantiation, constraint solver solving, collaborative diagnosis and hierarchical anomaly recovery), and an agent execution node (responsible for task execution and status feedback). These three nodes can work collaboratively through standardized data interfaces to form a closed loop of "perception-planning-decision-execution-learning." Specifically, the multi-agent collaboration platform node executes the method applied to the multi-agent collaboration platform node in this application, specifically for generating target tasks, forming pre-slice solution packages, and orchestrating collaborative processes, so that upper-layer business tasks are first decomposed into task slices with initial allocation information and initial constraints. The edge coordination node executes the method applied to the edge coordination node in this application on the side closer to the field, specifically by combining real-time perception information to quickly instantiate and solve the pre-slice solution package within a time limit, thereby outputting a task slice instruction set that better suits the current execution conditions. The agent execution node is used to receive and execute task slice instruction sets. Based on this, physical agents and virtual agents can form a closed-loop collaboration around the same target task, thereby reducing the impact of static allocation mismatch, central recalculation lag, and the spread of abnormal disturbances, thus improving the real-time adaptability, scheduling stability, and continuous execution capability of agent collaboration.

[0071] For example, Figure 1 This is a schematic diagram of the architecture of a multi-agent adaptive cooperative system provided in an embodiment of this application. Figure 1As shown, this multi-agent adaptive collaborative system adopts a four-layer architecture: a user interaction layer, a task parsing layer (i.e., a multi-agent collaborative platform system), an edge processing layer (i.e., an edge coordinator module), and a terminal execution layer (i.e., an agent execution module). The user interaction layer provides task input through a task interaction application. The task parsing layer may include an agent management center, a task creation center, a digital twin simulation center, and an anomaly handling center. This layer is responsible for offline global pre-planning: using a large language model to parse user requirements and generate structured task objectives, combining a global capability library and an environmental digital twin model to construct a constraint satisfaction problem model and perform simulation deduction, outputting a pre-sliced ​​solution package. The edge processing layer has a built-in constraint solver and anomaly handling strategy library. After receiving the pre-slice package, it injects real-time perception information, instantiates it into a dynamic constraint satisfaction problem, solves it within a millisecond-level time window, issues executable instructions, and simultaneously performs collaborative diagnosis and hierarchical anomaly recovery. The terminal execution layer consists of various agent execution modules, which provide status feedback through a data reporting module, and the executors receive and execute instructions. The four-layer collaboration forms a closed loop of "perception-planning-decision-execution-learning", thereby enabling adaptive collaboration among multiple agents in high real-time scenarios.

[0072] Next, we will explain in detail the responsibilities of the multi-agent collaboration platform nodes and the edge coordination nodes.

[0073] Figure 2 This is a flowchart illustrating a multi-agent adaptive collaboration method applied to a multi-agent collaborative platform node, as provided in an embodiment of this application. The method is executed by the multi-agent collaborative platform node (i.e., the platform side, hereinafter referred to as the "platform node"), and is mainly used to complete global pre-planning, generating a pre-sliced ​​scheme package that can be directly used by edge coordination nodes. Figure 2 As shown in the embodiments of this application, the multi-agent adaptive cooperation method applied to nodes of a multi-agent cooperative platform may include the following steps:

[0074] S201. Obtain the structured task objective of the target task to be processed.

[0075] For example, a structured task target is used to describe the target task to be processed as a computable and decomposable task expression, thereby providing a unified data input basis for subsequent constraint modeling, task slice generation, and allocation deduction. The target task to be processed, when actually accessed, is typically represented as a natural language work order, a business system order, a scheduling request message, a work instruction issued by the upper-level control system, or a collaborative task message generated by an event trigger, etc. After receiving the above information, the platform node can first complete task access, semantic parsing, field normalization, and relation extraction, and then form a structured task target. Optionally, the structured task target may include fields such as task object, task type, number of targets, time requirements, spatial scope, resource constraints, and dependencies with other tasks. This structured task target is typically represented in JSON, XML, or a custom structured format for direct invocation in subsequent steps.

[0076] In one possible embodiment, the platform node can receive target tasks to be processed via a message bus, application programming interface (API), industrial communication gateway, or database subscription interface. After receiving the target task, the platform node can use a task parsing module to structurally represent the task objects, task content, task constraints, and task-object relationships within the target task. For example, when the target task is a warehouse order fulfillment task, the platform node can parse it into multiple stages: picking, handling, sorting, verification, and outbound delivery, mapping each stage to structured fields with clearly defined inputs, outputs, execution conditions, and completion criteria.

[0077] By transforming unstructured user requirements into structured task objectives, the problem of ambiguous task descriptions in existing technologies, which cannot be directly used for constraint modeling, is solved, providing clear and computable input for the subsequent construction of constraint satisfaction problems.

[0078] Optionally, in one possible embodiment, obtaining the structured task target of the target task to be processed includes: parsing the user input requirements using a large language model to generate the structured task target of the target task.

[0079] For example, a Large Language Model (LLM) is used to semantically understand the user's needs, such as task intent, constraints, expected results, and execution preferences, described in natural language, and convert them into a structured task description that can be used for subsequent task slice modeling and constraint solving. In this application, the LLM can be a general pre-trained model or a domain model fine-tuned with industry corpus; the embodiments of this application are not limited to this.

[0080] In the specific implementation, the platform node can receive the task requirements input by the user in natural language through the task interaction application (such as "move 10 cases of beverages from the shelf in area A to the shipping outlet in area B"). Then, it uses the built-in large language model to parse the natural language requirements and extract the task type, task object, task constraints (such as time window and priority), the sequence of sub-tasks after task decomposition, and the dependencies between sub-tasks, thereby generating a standardized structured task objective.

[0081] By employing a large language model, unstructured user requirements can be stably converted into machine-processable target task expressions, reducing the cost of manual organization and secondary interpretation, and improving the consistency and traceability of task objectives in multi-agent collaborative links. Since structured task objectives contain key constraint information required for subsequent solutions, this helps improve the accuracy of task slice modeling, reduce scheduling deviations caused by semantic omissions or incomplete fields, and enhance the rapid response capability of edge coordination nodes to complex collaborative tasks.

[0082] S202. Based on the structured task objectives, global capability library, and environmental digital twin model, construct a constraint satisfaction problem model and conduct simulation deduction to generate a pre-sliced ​​solution package for the target task.

[0083] The global capability library includes capability vectors for each agent, an environmental digital twin model to simulate the application scenario to which the target task belongs, and a pre-slicing scheme package to indicate the initial allocation information and initial constraints of the task slices to which the target task is decomposed.

[0084] For example, this step is the core of the platform's global pre-planning. The platform node takes the structured task objectives obtained in S201, the pre-built and continuously maintained global capability library, and the environmental digital twin model as input, and generates a pre-sliced ​​solution package by building a constraint-satisfying problem model and performing simulation.

[0085] In this application, a global capability library is used to store the multi-dimensional capability vectors of each agent, serving as the basis for task slice allocation and constraint solving. A task slice is a basic execution unit formed by atomically decomposing a target task, carrying the capability requirements, time requirements, and resource consumption requirements of a single schedulable stage. Specifically, the capability vectors in the global capability library can be uniformly modeled using multi-dimensional parameters to simultaneously describe the participation capabilities of both physical and virtual agents. For physical agents, capability vectors may include movement speed, load limit, end effector type, reachability, positioning accuracy, remaining battery power, current location, available working time window, and security level. For virtual agents, capability vectors may include service type, interface throughput, average response time, concurrent processing limit, algorithm model version, resource utilization, call dependency chain information, and service availability level.

[0086] An environmental digital twin model is a digital mapping of a physical or virtual task space. It includes the static structure of the application scenario (such as shelf layout and network topology), dynamic elements (such as equipment location and aisle occupancy status), and physical / logical rules (such as kinematic models and service call latency models). Specifically, depending on the application scenario of the target task, the environmental digital twin model can be a digital mapping of warehouse layout, production units, aisle networks, equipment topology, service dependency graphs, regional security boundaries, communication link status, and historical disturbance characteristics. It can originate from static configuration data or periodically synchronized scenario update data. Taking a logistics warehousing scenario as an example, the environmental digital twin model can include shelf locations, station coordinates, path connection relationships, aisle widths, equipment docking areas, loading and unloading stations, conveyor line status, and buffer capacity. Taking a hardware and software collaborative scenario as an example, the environmental digital twin model can also include service call chains, task orchestration dependency graphs, computing resource pool distribution, and network latency matrices.

[0087] The Constraint Satisfaction Problem Model (CSP model) is used to unify information from structured task objectives, a global capability library, and an environmental digital twin model into a solvable mathematical model. The CSP model is a triple consisting of decision variables, the domains of the variables, and constraints. The decision variables in this model include task slice allocation object variables and task slice start time variables. For more granular scheduling, path selection variables, cache occupancy variables, service instance binding variables, retry count variables, and resource locking interval variables can also be included. Constraints include at least capability matching constraints, timing constraints, and resource mutual exclusion constraints. Capability matching constraints ensure that the capability vector of the executing entity meets the execution requirements of the corresponding task slice. Timing constraints ensure that task slices with dependencies are executed in logical order. Resource mutual exclusion constraints prevent shared devices, shared channels, shared service instances, or shared workstations from being simultaneously occupied by incompatible tasks. Depending on the specific scenario, spatial conflict constraints, time window constraints, capacity constraints, energy consumption constraints, service chain consistency constraints, and anomaly recovery reservation constraints can also be added to the model.

[0088] Simulation and derivation are used to simulate and calculate the constraint satisfaction problem model in the digital twin model of the environment. The pre-slice scheme package serves as the pre-planning output of the platform side, indicating the initial allocation information and initial constraints of the task slices decomposed from the target task, and providing basic input for subsequent real-time fine-tuning of the edge coordination nodes.

[0089] In one possible embodiment, the platform node first extracts a set of candidate agents related to the current target task from the global capability library. For example, the platform node can match and filter each capability vector according to the content to be executed and the execution conditions in the structured task objective, thereby forming a candidate execution subject domain for each task slice. This candidate execution subject domain directly determines the range of values ​​of the allocation object variables in the constraint satisfaction problem model, and its construction accuracy affects the subsequent solution efficiency and the quality of feasible solutions. Then, the platform node retrieves the environmental digital twin model corresponding to the business scenario to which the target task belongs. By mapping the structured task objective to the environmental digital twin model, the constraint background of the task slice in the spatial, temporal, and resource dimensions can be obtained, making the pre-planning results more in line with the real scenario. After establishing the constraint satisfaction problem model based on the structured task objective, candidate execution subject domain, and environmental mapping results, the platform node uses the environmental digital twin model as a simulation environment and employs Monte Carlo Tree Search (MCTS), offline reinforcement learning, or other optimization algorithms to perform large-scale simulation and deduction of the above constraint satisfaction problem model. During the simulation, the algorithm searches for high-quality allocation schemes while satisfying all constraints. The optimization objective can be minimizing the total task completion time, minimizing total energy consumption, or agent load balancing, etc. After the simulation, the platform nodes encapsulate the solution results into a pre-sliced ​​scheme package.

[0090] Understandably, the pre-slicing solution package is not a final execution instruction, but a collection of "high-quality initial solutions + constraint boundaries," and may contain one or more backup solutions (e.g., alternative allocation schemes that can be directly invoked when the edge side fails or times out). It provides an excellent starting point for edge coordination nodes, thus avoiding the computational and time overhead of solving from scratch on the edge side. In this application, the pre-slicing solution package is used to indicate the initial allocation information and initial constraints of the task slices decomposed from the target task. The initial allocation information provides a preliminary matching relationship between each task slice and the recommended agent ID; the initial constraint set includes the temporal dependencies between task slices, capability matching requirements, resource mutual exclusion rules, and spatial collision avoidance constraints predicted based on the environmental digital twin model. In collaborative scenarios, the pre-slicing solution package can contain both execution slices for physical agents and software service slices for virtual agents, enabling order parsing, inventory verification, path confirmation, and actual handling actions under the same target task to be processed in a unified model. In practical applications, the pre-slicing solution package can present the initial allocation information and initial constraints in different forms. For example, a pre-slicing scheme package may include: a) a slice dependency graph, which describes the temporal and logical dependencies between task slices in the form of a directed graph; b) an allocation mapping matrix, which indicates the initial matching relationship between each task slice and the recommending agent ID; c) a set of key constraints, which is a formal expression of the spatiotemporal constraints, performance constraints, etc. that must be followed in the simulation; and d) expected performance indicators, such as the estimated total completion time and total energy consumption.

[0091] It's important to note that this step is crucial for addressing the challenge of statically allocated results adapting to real-time changes in dynamic collaboration scenarios. By pre-establishing a constraint satisfaction problem model on the platform side, combining structured task objectives, a global capability library, and a digital twin model of the environment, and then simulating and extrapolating in a virtual environment, a pre-sliced ​​solution package with a feasible foundation, clearly defined constraint boundaries, and rapid edge adjustment can be generated before task execution. This eliminates the need for the edge side to perform a full decomposition and global solution of the complete task from scratch. Instead, it can perform local instantiation and time-limited corrections based on the pre-planning results provided by the platform, thereby reducing the online computational burden and shortening the time link between changes in the on-site state and the formation of executable instructions. Furthermore, by employing capability vectors, scenario twins, and multi-constraint joint modeling, it's possible to reduce conflict omissions caused by relying solely on empirical rules, improving the executability and robustness of multi-agent collaboration results under complex constraints.

[0092] Optionally, in one possible embodiment, based on the structured task objective, the global capability library, and the environmental digital twin model, a constraint satisfaction problem model is constructed and simulated to generate a pre-sliced ​​solution package for the target task, which may include:

[0093] S01. Based on the structured task objectives, the global capability library, and the environmental digital twin model, construct a constraint satisfaction problem model; wherein, the constraint satisfaction problem model includes decision variables and constraints related to the task slice;

[0094] S02. Using Monte Carlo tree search or offline reinforcement learning algorithms, the constraint satisfaction problem model is simulated and deduced in the digital twin model of the environment to generate a pre-sliced ​​solution package for the target task.

[0095] In this application, the constraint satisfaction problem model is a triple consisting of decision variables, the domains of the variables, and constraints, used to accurately characterize the allocation relationship between task slices and agents, as well as multi-dimensional constraints such as time, resources, and space. Based on this, when constructing the constraint satisfaction problem model, the target task can first be decomposed into task slices according to the structured task objective, and an allocation object variable (determining which agent will execute) and a start time variable (determining when execution begins) can be defined for each task slice. Then, the domain of the allocation object variable is established based on the global capability library; that is, based on the global capability library, a set of agent IDs whose capabilities meet the task requirements is selected. The domain of the start time variable is established based on the environmental digital twin model; that is, a reasonable time window is calculated based on task dependencies, spatial distance, deadlines, etc. Simultaneously, a constraint set is constructed based on the structured task objective, the global capability library, and the environmental digital twin model. The constraint set includes at least capability matching constraints, temporal constraints, and resource mutual exclusion constraints. Furthermore, the constraint set may also include cooperative and physical constraints, energy constraints, etc., which are not limited in this embodiment.

[0096] In the specific implementation, after receiving the structured task objective, the platform node parses the objective task into several task slices and establishes a corresponding decision node for each task slice. The domain of the allocation object variable is calculated by the global capability library, typically selecting a set of intelligent agents that meet the requirements based on capability tags such as handling, sorting, inspection, computing, or communication. The domain of the start time variable is derived from the environmental digital twin model, combining the task's pre-completion time, the shared channel's occupancy period, and the device's availability window to determine the possible start time range. In the constraint set, capability matching constraints are used to restrict the allocation object from meeting the capability requirements of the task slice, timing constraints are used to limit the sequential execution relationship between slices, and resource mutual exclusion constraints are used to restrict the same shared device, channel, or communication link from being occupied by multiple slices simultaneously during conflict periods.

[0097] For example, a platform node can denote task slices as a set X = {x1, x2, ..., xn}, and candidate agent set as A = {a1, a2, ..., am}. It defines the allocation object variable yi to represent the agent identifier assigned to task slice xi, the start time variable ti to represent the planned start time of task slice xi, and the order relation variable zij to represent the sequential relationship between task slices xi and xj. Capability matching constraints can be expressed as Cap(yi) ≥ Req(xi), where Cap(yi) represents the available capability value after mapping the capability vector of the selected agent, and Req(xi) represents the capability requirement value of the task slice. Timing constraints can be expressed as tj ≥ ti + di, where di represents the expected execution time of task slice xi. Resource mutual exclusion constraints can be expressed through non-overlapping interval constraints, where when task slices xi and xj compete for the same mutually exclusive resource, ti + di ≤ tj or tj + dj ≤ ti. The above formula is used to explain the principle of the model. Its function is to transform abstract business tasks into computable variables and constraints, thereby enabling platform nodes to select feasible solutions in the pre-planning stage and retain space for subsequent edge adjustments.

[0098] After the constraint satisfaction problem model is constructed, the platform node deploys it in the environmental digital twin model and performs simulation using an efficient optimization algorithm. In this embodiment, the algorithm can be Monte Carlo Tree Search (MCTS) or Offline Reinforcement Learning (Offline RL), but this application is not limited to these; any algorithm capable of finding high-quality solutions in a complex constraint space is applicable.

[0099] During simulation, Monte Carlo Tree Search (MCS) expands, samples, and evaluates different slice allocation paths multiple times within the digital twin model of the environment. It compares the performance of each candidate allocation result in terms of feasibility, completion latency, and resource consumption, ultimately selecting a pre-sliced ​​solution package. MCS can be performed online or offline without prior training, making it particularly suitable for task planning problems with complex constraints and large state spaces. Offline reinforcement learning algorithms, on the other hand, train a policy network based on historical collaborative data, simulation trajectory data, or pre-collected samples. This allows the network to output task slice allocation strategies without relying on online interaction and verify the constraint satisfaction of the strategies within the digital twin environment, ultimately forming a pre-sliced ​​solution package with high pre-feasibility. Offline reinforcement learning leverages the platform's rich historical task records to further improve the efficiency and solution quality of the simulation. Regardless of the algorithm used, the simulation is completed within the digital twin model of the environment, without interfering with the operation of the actual physical equipment. After the simulation, the platform nodes can output the solution results and package them into a pre-sliced ​​solution package.

[0100] Through this optional implementation, the platform can flexibly select the optimization algorithm most suitable for the current task scale and scenario complexity for simulation. MCTS requires no pre-training, is plug-and-play, and is suitable for environments with varying task patterns; offline reinforcement learning can utilize historical data to accelerate simulation, suitable for scenarios with relatively fixed task patterns. Both can fully utilize the simulation capabilities of the environmental digital twin model to search for globally optimal or near-optimal initial allocation schemes without risk, thereby providing high-quality pre-sliced ​​scheme packages for edge coordination nodes, significantly reducing the difficulty and time pressure of real-time solutions on the edge side, and thus improving the real-time performance, stability, and task completion rate of multi-agent collaboration.

[0101] Optionally, in one possible embodiment, when an environmental digital twin model of the application scenario to which the target task belongs has not been pre-built, before executing step S202, it is also necessary to: first build an environmental digital twin model of the application scenario to which the target task belongs, and then update the environmental digital twin model according to changes in the application scenario. In actual implementation, platform nodes can pre-compile initialization by connecting to map files, device ledgers, interface service tables, etc., and connect to real-time sensing data sources. Then, after receiving environmental change events, they can update relevant entity attributes and constraint parameters incrementally to ensure the timeliness of the environmental digital twin model.

[0102] Similarly, if a global capability library is not pre-built, it is necessary to: first, perform unified capability modeling on each registered agent, quantifying the function of each agent into a multi-dimensional capability vector to form a global capability library. Specifically, unified capability modeling can use standardized capability templates to abstract different types of agents. For example, for physical agents, battery level, robotic arm load, current position, and working mode can be recorded; for virtual agents, computing power quota, queue depth, call latency, and service availability can be recorded. Then, each field is mapped to a numerical component in the same dimensional system and written into the global capability library.

[0103] Furthermore, based on actual needs, a three-level anomaly system (L1, L2, and L3) and corresponding handling strategies can be predefined according to at least one of the security, reliability, and performance dimensions, thereby constructing an anomaly handling strategy library. Understandably, in practical applications, the anomaly handling strategy library can be deployed on the platform side or the edge coordination side; this embodiment does not impose any restrictions. The anomaly handling strategy library can be stored in the form of rule tables or policy dictionaries, and the table entries can include information such as anomaly triggering conditions, level identifiers, handling actions, and rollback conditions. After detecting an anomaly, the system can directly retrieve and execute the corresponding strategy without needing to perform extensive re-inference. As an example, Table 1 shows the handling strategy division corresponding to the three anomaly levels, and Table 2 shows the detailed definitions of the anomaly levels according to the three dimensions of security, reliability, and performance.

[0104] Table 1

[0105]

[0106] As shown in Table 1 above, it defines the handling strategies and corresponding specific operations for L1, L2, and L3 anomalies. L1 (Automatic Handling): Applicable to known, localized, and non-safety-related anomalies. The system does not need to interrupt the task flow; it directly executes pre-set standardized recovery procedures (such as restarting communication processes), fine-tunes its own or collaborating agent parameters (such as reducing speed), or logs and continues executing the current task. This level aims for rapid self-healing and avoids unnecessary intervention. L2 (Collaborative Reconstruction): Applicable to newly emerging anomalies or those affecting the task flow but not yet reaching the safety threshold. The system first freezes the affected task flow, then initiates local dynamic slice replanning at the edge layer (i.e., reusing the original constraint solver to reallocate tasks), directing relevant agents to execute the new plan, and asynchronously reporting the anomaly to the platform. This level achieves "solving problems at this layer," avoiding delays caused by backtracking to the platform. L3 (Safety Intervention): Applicable to severe anomalies involving personal safety, equipment safety, or complete task failure. The system immediately sends the highest priority emergency stop command to relevant agents, triggers on-site audible and visual alarms, and simultaneously notifies the nearest human safety officer. This level prioritizes safety and is willing to interrupt missions.

[0107] Table 2

[0108]

[0109] As shown in Table 2 above, the specific judgment criteria for L1, L2 and L3 anomalies are refined from three perspectives: security, reliability and performance. Through the above three-dimensional classification, the system can quickly match the appropriate handling strategy when an anomaly occurs, taking into account both efficiency and safety.

[0110] Through the above design, platform nodes can obtain an environmental foundation consistent with the site before the target task is generated, and quickly select executable agents based on a unified capability representation during the task issuance process. At the same time, they can also perform hierarchical responses to safety, reliability and performance-related anomalies, thereby reducing scheduling mismatch, shortening anomaly recovery time and improving the continuity and stability of multi-agent collaboration.

[0111] It should be noted that this application uses a three-level anomaly classification of L1, L2, and L3 as an example to clearly demonstrate the logical framework for anomaly classification and its corresponding differentiated handling strategies. However, the technical concept of this application is not limited to a three-level classification. In practical applications, designers can set anomaly levels to two, three, or more levels based on the security requirements, reliability requirements, performance requirements, and physical or virtual attributes of the agent in a specific business scenario. Each level can be configured with an appropriate handling strategy (such as automatic recovery, local replanning, security intervention, etc.). The core protection point of this application lies in the mechanism itself of "classifying anomalies and adopting differentiated handling strategies matching the levels," rather than the specific number or names of levels. Any technical concept that includes "anomaly classification determination + differentiated handling based on levels" should be considered to fall within the protection scope of this application.

[0112] S203. Distribute the pre-sliced ​​solution package to the edge coordination node.

[0113] For example, the platform node sends the pre-slicing scheme package generated by S202 to one or more edge coordination nodes responsible for the current task area through a standardized data interface. The distribution is typically performed immediately after the pre-slicing scheme package is generated, or in batches according to a task scheduling strategy. Upon receiving the scheme package, the edge coordination node caches it locally and waits for real-time sensing information to trigger instantiation and solution.

[0114] By delegating the pre-slicing scheme package to edge nodes closer to the field, this step decouples "global pre-planning" from "local real-time decision-making." The platform side does not need to worry about millisecond-level real-time changes, and the edge side does not need to bear heavy computational burdens. The two perform their respective functions and work together to achieve adaptive collaboration in high real-time scenarios.

[0115] For example, Figure 3 This is a schematic diagram of the internal structure of a node in a multi-agent collaborative platform provided in an embodiment of this application. Figure 3 As shown, the nodes of a multi-agent collaboration platform can include: an agent management center, a task creation center, a digital twin simulation center, and an anomaly handling center. Combined with... Figure 2 and Figure 3The intelligent agent management center can complete the unified access of intelligent agents through the intelligent authentication and registration module, and store the multi-dimensional capability vectors (such as speed, load, etc.) of each intelligent agent in the intelligent agent capability vector library (i.e., the aforementioned global capability library). The task creation center can use the large language model management module to parse user requirements, generate structured task objectives, and store them in the requirement task pool. The digital twin simulation center can include a digital twin module (for building a digital mapping of the environment), an environment map module (for providing spatial layout), a constraint management module (for defining constraint rules such as capability matching, timing, and mutual exclusion), and a simulation inference module (for solving constraint satisfaction problems using algorithms such as Monte Carlo tree search), which together complete global pre-planning and output pre-slice solution packages. The anomaly handling center can predefine L1 / L2 / L3 three-level anomalies according to the dimensions of safety, reliability, and performance through the anomaly classification management module, and store the corresponding deterministic handling strategies in the anomaly handling strategy library. This platform-side structure provides key inputs such as capability libraries, twin models, pre-slice packages, and strategy libraries for subsequent real-time scheduling and anomaly recovery at the edge side.

[0116] The multi-agent adaptive collaboration method provided in this embodiment, applied to nodes of a multi-agent collaborative platform, first involves the platform node performing a structured description of the target task, then integrating global capability information with the digital twin model of the environment to complete constraint modeling and simulation, and finally transmitting the resulting pre-sliced ​​solution package to the edge coordination node. This transforms the task allocation process, which originally relied on static rules or was determined once before execution, into a hierarchical collaboration process with a pre-planned foundation. On the one hand, the pre-sliced ​​solution package provides the edge coordination node with a high-quality initial solution, allowing it to output the final executable instruction with only local fine-tuning within a millisecond time window, significantly reducing the real-time scheduling complexity on the edge side. On the other hand, the platform side utilizes the global capabilities of the agents and the digital twin model of the application scenario to which the target task belongs for large-scale simulation, ensuring the global optimality of the allocation scheme and avoiding the edge side from falling into suboptimal solutions due to information locality. Simultaneously, by using multi-dimensional capability vectors to uniformly abstract physical and virtual agents, it achieves capability description and constraint matching of agents within the same framework, exhibiting good scalability. In summary, this solution effectively supports the collaborative architecture of "global pre-planning - edge real-time fine-tuning", improving the efficiency, overall operational stability and robustness of multi-agent collaboration in high real-time scenarios.

[0117] The above combination Figure 2 and Figure 3 This paper describes in detail a method embodiment on the node side of a multi-agent collaborative platform. The following will combine... Figure 4 This describes the specific implementation on the edge coordination node side. For example, Figure 4This is a flowchart illustrating a multi-agent adaptive collaboration method applied to an edge coordination node, as provided in an embodiment of this application. The method is executed by the edge coordination node (i.e., the edge side), which is primarily responsible for making real-time scheduling decisions close to the field, converting the pre-sliced ​​solution package generated by the platform side into task slicing instructions that the agents can directly execute. Figure 4 As shown in the embodiments of this application, the multi-agent adaptive cooperation method applied to edge coordination nodes may include the following steps:

[0118] S401. Obtain the pre-slice scheme package generated for the target task; wherein, the pre-slice scheme package is used to indicate the initial allocation information and initial constraints of the task slices decomposed by the target task.

[0119] For example, edge coordination nodes can be deployed as edge servers within warehouse control cabinets, industrial computers, gateway devices with local computing power, or edge computing units integrated into scheduling controllers. Their role is to perform online replanning based on real-time on-site conditions. The target task can be an order fulfillment task, a batch handling task, an inspection process task, or a composite business task that includes physical execution and software service processing. To enable the edge side to solve the problem quickly within a limited time, it is first necessary to obtain a pre-sliced ​​solution package corresponding to the target task. For example, the pre-sliced ​​solution package can be obtained from the upper-layer platform, task management service, solution repository, or local cache.

[0120] Optionally, when a pre-slice solution package is generated by a platform node, obtaining the pre-slice solution package generated for the target task may include: receiving a pre-slice solution package issued by a multi-agent collaboration platform node. The multi-agent collaboration platform node is used to construct a constraint satisfaction problem model and perform simulation deduction based on the structured task objectives, global capability library, and environmental digital twin model of the target task, in order to generate the pre-slice solution package; the global capability library includes the capability vectors of each agent, and the environmental digital twin model is used to simulate the application scenario to which the target task belongs.

[0121] Specifically, edge coordination nodes can receive pre-sliced ​​solution packages via wired industrial Ethernet, wireless LAN, message queues, remote procedure call interfaces, or shared database subscriptions. When real-time requirements are high, the platform can proactively push the packages to the edge coordination nodes after task generation and index and cache them at the edge to reduce subsequent retrieval latency. For example, the platform can complete capability matching, constraint modeling, and scenario simulation before the target task enters the field for execution, ensuring the pre-sliced ​​solution package carries relatively complete initial collaboration information. Upon receiving the package, the edge coordination node can quickly instantiate the current execution conditions without re-modeling the entire task, thus shortening scheduling preparation time and reducing execution mismatch caused by inconsistencies between static allocation and field conditions. Because the pre-sliced ​​solution package has already undergone simulation screening combining digital twin scenarios and capability vectors, the solution results for subsequent task slice instruction sets have higher feasibility and stability, improving the real-time adaptability and overall execution efficiency of agent collaboration.

[0122] By pre-acquiring pre-sliced ​​solution packages with completed task decomposition and initial constraint organization, edge coordination nodes no longer need to model complex tasks from scratch. Instead, they can quickly instantiate and locally adjust existing solution skeletons. This approach moves the highly complex global planning to the platform side while leaving real-time adaptation decisions to the edge. This significantly reduces online solution modeling costs while ensuring the basic feasibility of the solution, providing a data foundation for generating executable results within a short time window. This directly supports multi-agent collaborative scenarios with frequently changing field conditions.

[0123] S402. Based on real-time sensing information, instantiate the pre-sliced ​​scheme package into the current constraint satisfaction problem model.

[0124] For example, this step is a crucial step in achieving dynamic absorption of on-site conditions and rapid implementation of task plans. After acquiring the pre-sliced ​​plan package, the edge coordination node does not directly issue it for execution according to the initial allocation result. Instead, it continuously receives real-time sensing information from various sensing sources on-site and maps this real-time sensing information to updates of task slices, variable domains, candidate sets, and constraints, thereby instantiating the pre-sliced ​​plan package into a constraint satisfaction problem model that meets the current execution conditions. The real-time sensing information reflects the current state of the execution environment and the agent. Its sources can include power consumption, load, location, speed, fault codes, and currently occupied resource information reported by physical agents; service load, queue length, interface response time, processing throughput, and abnormal states reported by virtual agents; channel occupancy, local obstacle status, temperature and humidity, access control status, and workstation occupancy status collected by the environmental sensing module; and task insertion, task cancellation, priority changes, and timeliness changes reported by the task management system, etc.

[0125] In practical implementation, edge coordination nodes can acquire real-time sensing information by subscribing to message buses, polling status interfaces, receiving device heartbeat packets, parsing industrial protocol messages, or accessing edge time-series databases. To ensure state validity, edge coordination nodes can attach a collection timestamp, state confidence level, source identifier, and validity period parameter to each type of real-time sensing information, and first perform standardization processing to uniformly map state variables from different sources into variable forms suitable for solver processing. For example, the robot's current position is mapped to a path reachability variable, the remaining battery power is mapped to an execution capacity upper limit constraint, the average service response latency is mapped to a filtering condition for the virtual agent's selectable domain, channel congestion information is mapped to spatial mutual exclusion or path prohibition constraints, and emergency order insertion information is mapped to task priority promotion and related time window reduction constraints. In this way, the initial allocation information and initial constraints originally statically described in the pre-sliced ​​solution package are injected with the current state, forming a solvable model oriented towards the current moment.

[0126] Through instantiation, the static pre-solution originally generated based on global historical information is transformed into a dynamic constraint satisfaction problem model reflecting the current moment, current location, current environment, and current task priority. This model retains the core structure (variable definitions, basic constraint framework) of the pre-solution package, but the variable domain and constraint conditions have been corrected with real-time information, making it more closely aligned with the actual situation on-site. Based on this, the problem of static task allocation results failing to reflect the on-site state in a timely manner is effectively solved. This allows the subsequent solution process to no longer rely on outdated information but directly search for feasible solutions based on the current execution conditions, thereby improving the adaptability of the collaborative system to environmental changes, capability fluctuations, and task disturbances, and reducing the risk of execution mismatch caused by the disconnect between the initial plan and the actual on-site situation.

[0127] Optionally, in one possible embodiment, the real-time sensing information includes at least one of the following: real-time state information of agents within a preset jurisdiction, environmental change information, and task change information; instantiating the pre-sliced ​​scheme package into the current constraint satisfaction problem model based on the real-time sensing information may include:

[0128] S1. Update the set of candidate agents for the task slice allocation object variables in the problem model that satisfy the constraints based on real-time status information.

[0129] S2. Based on environmental change information and / or task change information, dynamically update the variable domain and constraint conditions of the constraint satisfaction problem model to obtain the current constraint satisfaction problem model.

[0130] For example, the preset jurisdiction refers to the spatial or logical range that the edge coordination node can directly access and manage. Real-time status information of the intelligent agent can typically be collected by the field perception module, device telemetry interface, or service monitoring interface, and may include data such as power consumption, load, current location, communication quality, computing power usage, and online status. Environmental change information can be obtained by visual sensors, map update modules, or obstacle detection modules, and may include temporary obstacles, channel congestion, etc. Task change information can be issued by the upper-layer task management module, reflecting situations such as task priority adjustments, order insertion, or changes in dependencies, such as high-priority task preemption. After receiving this information, the edge coordination node uses it as the instantiation basis for the current constraint satisfaction problem model, transforming the pre-sliced ​​solution package from a static initial solution into a solution model usable in the current field.

[0131] During instantiation, not only are the variable domains updated, but constraints are also dynamically adjusted. Specifically, the edge coordination node filters the executable capabilities of agents in the candidate agent set based on the agents' real-time state information, eliminating those that do not meet the conditions, such as insufficient power, communication interruption, unsatisfactory location, excessive load, or insufficient computing power, and forming a new candidate agent set with the remaining agents. Optionally, the candidate set can be calculated by intersecting the capability vectors required by the task slice, spatial reachability, and temporal availability to ensure that the value of each variable corresponds to the currently executable agent. For environmental and task change information, the edge coordination node further modifies the variable domains and constraints. For example, when the channel is blocked, the range of path-related variables is narrowed; when a new task is inserted, the order constraints and resource mutual exclusion constraints between task slices are added; when the priority changes, the time limit constraints and sorting constraints of the task slices are adjusted, etc. Through the above updates, a constraint satisfaction problem model consistent with the current field state is formed for direct processing by the subsequent solver.

[0132] The optional instantiation method described above allows the pre-sliced ​​solution package to no longer rely on fixed assumptions at the time of generation, but to continuously modify the feasible region as the real-time state, environment, and task change. Instantiation using this method can effectively reduce invalid candidate solutions, improve the executability of the solution results, and reduce the number of task reassignments caused by state drift, thereby improving the real-time performance, stability, and continuity of agent collaboration.

[0133] S403. Call the constraint solver to solve the constraint satisfaction problem model within a preset time window and output an executable task slice instruction set.

[0134] For example, after instantiation, the edge coordination node invokes its built-in lightweight constraint solver to solve the current constraint satisfaction problem model within a time limit. Optionally, the constraint solver can be a rule-enhanced constraint solving engine, an integer constraint solving module, a heuristic search module, a backtracking search module, a local search module, or a combination of the above algorithms deployed on the edge side. In this application, the edge coordination node sets a strict upper limit on the solution time (e.g., ≤50 milliseconds, which can be dynamically configured according to specific application scenarios such as logistics handling and code compilation) to ensure that the entire scheduling decision can be completed in milliseconds. The specific value of this time window can be set to milliseconds, hundreds of milliseconds, or seconds according to specific application scenarios (such as logistics handling and code compilation), and can be dynamically adjusted in combination with task priority, on-site change frequency, and edge node computing power.

[0135] For example, upon receiving the model, the edge coordination node starts a solver timer and inputs the task slice variables, variable domain, constraint set, and optimization objective into the constraint solver. The solver first performs constraint propagation, variable domain pruning, and conflict detection to eliminate obviously infeasible variable combinations as quickly as possible. Then, it searches for feasible solutions that satisfy the current constraints according to a predetermined search strategy. If a feasible solution is found within a preset time window, it is further mapped to a combination of task slice allocation, execution order, and execution time, resulting in a task slice instruction set. Each task slice instruction contains at least one corresponding agent identifier (clearly specifying which agent will execute it) and execution time constraints (e.g., planned start time, latest completion time, or execution duration), thus making the instructions directly executable. Unlike probabilistic scheduling based on neural network inference, the constraint solver outputs deterministic allocation results based on precise mathematical logic, and all decisions are traceable and verifiable.

[0136] This step introduces a preset time window, subjecting the solution process to explicit real-time constraints. This prevents indefinite delays in response in pursuit of global optimality, thus establishing a controllable balance between real-time performance and solution quality. The constraint solver rapidly solves dynamically updated models under time-constrained conditions, compressing complex field constraints into immediate, executable decisions at the edge. This solves the computational lag problem inherent in centralized scheduling in high-frequency changing scenarios and avoids the difficulty of handling complex constraint conflicts by relying solely on fixed rules. Therefore, it improves the continuous operation capability of multi-agent collaborative systems under abnormal disturbances and real-time changes.

[0137] Optionally, in one possible embodiment, the constraint solver is invoked to solve the constraint satisfaction problem model within a preset time window, and the executable task slice instruction set is output, which may include:

[0138] S10. Input the constraint satisfaction problem model into the constraint solver for solving;

[0139] S20. If a feasible solution that satisfies all constraints is found within the preset time window, then a task slice instruction set is generated based on the feasible solution.

[0140] S30. If no feasible solution is found within the preset time window, the rollback mechanism is triggered, and a task slicing instruction set is generated based on the backup solutions contained in the pre-slicing solution package.

[0141] For example, a feasible solution refers to the variable assignment result that simultaneously satisfies all explicit and implicit constraints when the constraint solver outputs the solution, and can be directly mapped to the execution subject, execution order, and triggering conditions corresponding to each task slice. In this embodiment, the constraint solver can adopt a solution unit based on a combination of constraint propagation and search backtracking. Internally, it maintains the variable domain, constraint relationships, and current assignment state, and performs a linked solution for the allocation object, time sequence, resource mutual exclusion relationship, and execution capacity of the task slice after the input constraints satisfy the problem model.

[0142] In practical implementation, the constraint satisfaction problem model is first converted into a set of variables, domains, and constraints recognizable by the solver before being fed into the solution engine. The solution engine continuously performs consistency checks and candidate assignment expansion within a time window. When any feasible solution satisfying all constraints is found, the edge coordination node can organize the allocation results, timestamps, and constraint satisfaction states of that feasible solution into a task slice instruction set and encode it into scheduling instructions executable by the corresponding agent. Alternatively, if multiple feasible solutions are found, the optimal solution can be searched among them. If no feasible solution is found before the preset time window expires, the current constraints are considered too tight or the state changes too rapidly. The system triggers a rollback mechanism, directly reading the pre-prepared backup solutions from the pre-sliced ​​solution package and generating a task slice instruction set based on the predefined alternative allocation relationships, backup execution order, and degradation constraints in the backup solutions. The backup solutions in the rollback mechanism are used to maintain continuous task progress in the event of no solution or timeout, preventing task chain interruption due to solution failure.

[0143] In this manner, the constraint solver prioritizes solving the current model within a time limit to ensure that the task slice instruction set closely matches the real-time state. When the solution is successful, the output directly reflects the optimal or feasible allocation under the latest constraints. When the solution fails, it immediately switches to the backup solution generation path to ensure that the system can always output executable instructions. Thus, the edge coordination node can balance solution accuracy and response time in dynamic environments, reduce recalculation waiting caused by changes in the field, and improve the continuity and stability of multi-agent collaboration.

[0144] Optionally, in one possible embodiment, if there are multiple feasible solutions, generating a task slice instruction set based on the feasible solutions may include: before the end of a preset time window, finding the optimal solution among the feasible solutions according to a preset optimization objective, and generating a task slice instruction set based on the optimal solution.

[0145] For example, a preset optimization objective is used to select the best solution among multiple feasible solutions. This objective can characterize one or more of the following: task completion latency, agent load balancing, resource utilization, number of path conflicts, or switching costs. Based on this objective, the edge coordination node can uniformly evaluate different feasible solutions to determine the optimal solution that meets the current collaboration requirements. It should be noted that a "feasible solution" here refers to an effective allocation scheme obtained under the premise of satisfying task dependencies, resource mutual exclusion constraints, and agent capability constraints; the optimal solution is the scheme with the best performance after calculation using the objective function within the set of feasible solutions.

[0146] In practical implementation, after the constraint solver outputs multiple feasible solutions, the edge coordination node maps each feasible solution to a corresponding evaluation vector and calculates a comprehensive score based on a preset optimization objective. The scoring process can be completed using weighted summation, hierarchical constraint comparison, or single-objective ranking. If the preset optimization objective is the shortest completion time, the feasible solution with the shortest total execution time and no resource conflicts will be selected first. If the preset optimization objective is the lowest resource consumption, the solution with the lowest shared resource consumption will be selected while meeting the task completion requirements. If the preset optimization objective includes multiple evaluation dimensions, a unified objective value can be formed based on the weights of each dimension, and the feasible solution with the optimal objective value will be selected. After completing this selection process before the preset time window ends, the edge coordination node determines the execution subject, execution order, time constraints, and relationships of each task slice based on the optimal solution, and generates a task slice instruction set to be sent to the corresponding agent.

[0147] The aforementioned alternative implementations further filter feasible solutions within time constraints, ensuring that the task slice instruction set not only meets basic executability but also aligns with on-site optimization requirements, thereby improving the overall efficiency and stability of task allocation results. Since the optimal solution is selected from multiple feasible options based on the current real-time state, it reduces resource waste, minimizes task conflicts, and enhances real-time adaptability and execution consistency in agent collaboration scenarios.

[0148] S404. Send the task slice instruction set to the corresponding intelligent agent for execution.

[0149] For example, after generating the task slice instruction set, the edge coordination node distributes the instruction set to the corresponding intelligent agent for execution according to the execution relationship, thereby completing the closed-loop implementation from online solution to on-site execution. The corresponding intelligent agent is used to actually execute the task slice instruction set. Depending on the target task, it may be a physical intelligent agent such as a handling robot, robotic arm, conveyor control unit, sorting equipment, or inspection robot, or a virtual intelligent agent such as an order service, inventory service, path management service, data verification service, or resource scheduling service. Optionally, the edge coordination node can organize the distribution in a one-to-one, many-to-one, or one-to-many manner according to the mapping relationship between the task slices and the execution entities in the task slice instruction set. For example, a handling task slice can be distributed to a handling robot for independent execution, a composite sorting slice can be distributed to both the conveyor control unit and the sorting robotic arm for collaborative execution, and a data aggregation slice can be split and distributed to multiple service instances for parallel processing. The distribution process can be implemented through industrial communication protocols, device control interfaces, service call interfaces, message publish-subscribe mechanisms, or edge proxy forwarding mechanisms. The message may include task slice identifiers, execution parameters, planned start time, preconditions, feedback requirements, and exception handling flags, etc. This application embodiment does not impose any restrictions.

[0150] In practical implementation, to ensure reliable instruction transmission and execution, the edge coordination node can wait for the corresponding agent to return a confirmation message after issuing the instruction. If no confirmation is received within a set time, it can resend the instruction, switch communication links, or trigger a backup execution entity to take over. After receiving the task slice instruction, the corresponding agent completes its assigned task slice according to the instruction set and sends back the execution status, phase results, anomaly alarms, and completion flags to the edge coordination node or upper-layer platform. The edge coordination node can use this feedback as new real-time sensing information input, thereby re-entering the instantiation and solution process when subsequent tasks are not yet completed or the on-site state continues to change, forming a continuous closed-loop adaptive collaboration mechanism.

[0151] In one possible implementation, the edge coordination node includes a version number and an effective time tag when issuing task slice instruction sets to avoid execution confusion caused by the overlap of old and new instructions. When there are task slices already in execution on-site, the edge coordination node only sends update instructions to task slices that have not yet started or can be interrupted, while retaining the original execution schedule for uninterruptible task slices, thereby controlling the scope of reassignment and reducing execution oscillations. In another possible implementation, the edge coordination node can also issue task slice instruction sets in batches according to priority and dependency order, allowing high-priority, strongly dependent critical slices to be executed first, while delaying the issuance of secondary slices, to adapt to scenarios with limited communication bandwidth or limited device receive buffer.

[0152] It should be noted that the purpose of this step is not only to complete the instruction transmission, but also to truly transform the solution results into on-site collaborative behavior, and to establish a complete closed loop from perception, modeling, solving to execution through state feedback. By orderly distributing task slice instruction sets to corresponding intelligent agents of different types, the edge coordination node enables physical execution units and virtual service units to form a linkage execution relationship around the same target task, reducing waiting, conflict, and idle phenomena caused by the disconnect between the execution layer and the scheduling layer, thereby improving the continuity and collaborative stability of the overall task chain.

[0153] In this embodiment, the multi-agent adaptive collaboration method for edge coordination nodes provided in this application acquires a pre-generated pre-slice solution package, combines it with real-time perception information to instantiate it into a dynamic constraint satisfaction problem, and calls a lightweight constraint solver to output executable instructions containing agent identifiers and execution time constraints within a millisecond-level time window. This effectively fills the capability gap in the prior art, from semantic task description to specific execution instructions regarding "who does it and when it does it," achieving millisecond-level response in high real-time scenarios. Simultaneously, this method starts with the globally optimal pre-solution and only performs local fine-tuning based on real-time information, balancing global optimality with dynamic adaptability. By dynamically updating the variable domain and constraints, it can automatically adapt to agent state changes, environmental obstacles, and preemption of high-priority tasks, significantly enhancing the robustness of the collaborative system. Furthermore, the deterministic output based on the constraint solver avoids the problems of uninterpretable and unverifiable probabilistic models, providing a reliable technical foundation for scheduling decisions, thus ensuring the overall efficiency, real-time performance, and reliability of multi-agent collaboration. In summary, this method reduces the complexity of online modeling by using pre-slicing scheme packages, improves the consistency between the model and the field state by using real-time perception information, controls response latency by using preset time windows, and forms an execution closed loop by using task slice instruction set issuance and state feedback. Therefore, it can improve the real-time adaptability, task allocation accuracy, anomaly recovery continuity, and overall operational stability in the multi-agent collaboration process.

[0154] Optionally, in Figure 4 Based on its optional implementations, in one possible embodiment, the multi-agent adaptive cooperation method applied to edge coordination nodes in this application may further include:

[0155] S100. During the execution of the task slice instruction set, monitor the execution status of the intelligent agent;

[0156] S200. When an abnormal event is detected, trigger multiple other intelligent agents within the preset jurisdiction to report the observation data of the abnormal intelligent agent.

[0157] S300: Consensus processing of observation data based on a weighted consensus protocol to determine collaborative diagnostic results;

[0158] S400. Based on the collaborative diagnosis results, perform graded abnormality handling.

[0159] For example, in this embodiment, the execution status is used to characterize the progress, deviation, and whether abnormal triggering conditions occur during the execution of the task slice instruction set. The edge coordination node can continuously receive operational feedback, task completion rate, resource utilization, and communication heartbeat information reported by each agent, perform time-series comparisons and threshold judgments to identify abnormal events. Abnormal events can manifest as execution timeouts, action mismatches, path blocking, resource conflicts, device failures, or communication interruptions. After confirming an anomaly, the abnormal agent is marked as a target for diagnosis, and observation requests are sent to multiple other agents within its preset jurisdiction, prompting them to report observation data on the abnormal agent. The observation data may include information such as location deviation, neighborhood environment perception results, execution status of adjacent tasks, load changes, and communication link quality, used to reconstruct the source and scope of the anomaly.

[0160] In data processing, edge coordination nodes can perform consensus processing on observation data reported by multiple agents based on a weighted consensus protocol. The weights of different agents are assigned based on their spatial proximity to the anomalous agent, the reliability of historical observations, the integrity of current data, and perception accuracy. Consensus processing can employ a weighted voting mechanism (e.g., voting on the existence of anomalies, where anomalies are considered valid if the sum of weights exceeds a threshold) or a weighted average fusion (e.g., weighted averaging of continuous observations such as location deviations to obtain more accurate estimates) to reduce the interference of low-confidence data on diagnostic conclusions. During consensus processing, the weighted observation data undergoes consensus iteration or fusion to form a unified collaborative diagnostic result, which is used to output the anomaly type, severity, and scope of impact. Based on the collaborative diagnosis results, the edge coordination nodes perform hierarchical processing of anomalies. For example, when the anomaly is of low severity, only local reset, retry, or path correction can be performed on the anomalous agent. When the impact of the anomaly extends to the local collaborative link, local replanning or task switching can be triggered. When the anomaly is a serious fault or poses a security risk, pause, isolation, or emergency stop measures are taken to suppress the spread of the anomaly and maintain the overall collaborative stability.

[0161] By employing the above methods, anomalies can be detected in a timely manner during the task slice execution phase. With the help of collaborative observation and weighted consensus among multiple agents, a more accurate diagnostic conclusion can be formed, thereby matching the anomaly handling with the anomaly level, reducing misjudgments and excessive reconstruction, and improving the continuity, robustness, and on-site recovery efficiency in the multi-agent collaboration process.

[0162] Optionally, in one possible embodiment, performing graded anomaly handling based on the collaborative diagnosis results may include: matching the anomaly level and handling strategy corresponding to the collaborative diagnosis results according to the anomaly handling strategy library, and executing the matched handling strategy.

[0163] The exception handling strategy library includes predefined exception levels and corresponding handling strategies based on at least one of the following dimensions: security, reliability, and performance. The exception levels include L1, L2, and L3. If it is L1, a preset recovery procedure or fine-tuning parameters is executed. If it is L2, the relevant task flow is frozen, and the constraint solver is called to perform local dynamic slice replanning, generate a recovery plan, and issue it. If it is L3, an emergency stop command is sent and an alarm is triggered.

[0164] For example, an anomaly handling strategy library is used to pre-store handling rules corresponding to different anomaly severity levels. The library can map security risks, reliability degradation, and performance deterioration to different levels of anomaly identifiers, and establish associations between actions such as recovery procedures, parameter fine-tuning, task freezing, local replanning, emergency stops, and alarms. This allows edge coordination nodes to directly complete matching calls after determining the collaborative diagnostic results. Anomaly levels reflect the degree of impact of anomalies on task continuity, execution security, and resource consumption. As shown in Tables 1 and 2, L1 corresponds to minor deviations, L2 to local mismatches, and L3 to severe anomalies with security risks. Different anomaly levels and scenarios typically have different handling strategies. Pre-set recovery procedures may include reconnecting communication links, resetting task states, rolling back local caches, or reloading execution parameters. Fine-tuning parameters can be modified for the timing, thresholds, frequency, or resource quotas of task slices. When freezing related task flows, the task chain associated with the anomaly object can be paused, and the current constraints can be input into the constraint solver to generate local dynamic slice replanning results. The recovery plan is then distributed to the corresponding agent for execution. After an emergency stop command is sent, the audible and visual or network alarm units can be driven to output alarm information to suppress the further spread of the anomaly.

[0165] It's important to note that the "local dynamic slice replanning" in L2 anomaly handling is not a complete re-solution detached from the platform-side pre-planning results. Instead, it's based on the pre-slice solution package previously issued by the platform, with localized adaptive adjustments made at the edge. Specifically, when an L2 anomaly occurs (such as an agent failure or path blockage), the edge coordination node does not discard the original pre-slice solution package. Instead, it reuses the slice dependencies, key constraint sets, and initial allocation information of unaffected task slices, replanning only the local task flow affected by the anomaly. This design allows the edge-side replanning to inherit the results of the platform-side global optimization, avoiding a complete overhaul due to local anomalies, thus maintaining the overall optimality of the solution while ensuring recovery speed. In other words, the pre-slice solution package is the "skeleton" and "constraint boundary" of the local dynamic slice replanning, while the edge-side constraint solver performs "local repair" and "real-time adaptation" on this basis. Together, they form a complete closed loop from global pre-planning to local real-time recovery.

[0166] Understandably, different handling strategies correspond to different strategy execution processes, and this application embodiment does not impose any limitations. Taking two typical interruption scenarios in multi-agent collaboration—high-priority task preemption and abnormal interruption—as examples, the designed unified exception handling process can be divided into four core stages: First, in the interruption response stage, the edge coordination node immediately freezes the affected task slices and captures the complete execution context (including input data, intermediate states, environment snapshots, etc.); second, in the resource dynamic reorganization stage, the dynamic slice engine is started based on the latest available resources to replan the affected workflow (prioritizing new tasks in the preemption scenario, and transferring the faulty agent's tasks to other agents in the abnormal scenario); then, the unfinished work units are encapsulated into standardized "pending slices," retaining the task ID, context, and minimum resource requirements, and re-inserted into the scheduling queue; finally, when resources become available, the "pending slices" are allocated to suitable agents (possibly the original agent or other agents with sufficient capabilities), and the continuity of business is restored by loading the context. This process achieves adaptive recovery in interruption scenarios, ensuring the robustness and task continuity of the collaborative system.

[0167] In practical applications, the anomaly handling strategy library can be deployed in the local storage unit of the edge coordination node and quickly retrieved through hash indexes or key-value mappings. This allows for rapid anomaly level determination and strategy loading after the collaborative diagnostic results are confirmed. Alternatively, the anomaly handling strategy library can be deployed on the platform side as a global knowledge base, with edge nodes pulling the latest strategies upon startup or periodic synchronization. When the platform updates the strategy library, it can proactively push the changes to each edge coordination node to ensure consistency in anomaly classification. This application does not impose any limitations on this approach.

[0168] In the embodiments of this application, the continuity of collaboration is maintained by recovery or fine-tuning in the case of mild anomalies, the scope of task interruption is reduced by local replanning in the case of moderate anomalies, and the overall safety is ensured by emergency stop and alarm in the case of severe anomalies. This can effectively improve the robustness, real-time performance and security of multi-agent collaborative scenarios.

[0169] Optionally, in one possible embodiment, based on the foregoing embodiments, the multi-agent adaptive collaboration method applied to edge coordination nodes may further include: reporting the anomaly handling results and newly emerging anomaly patterns to the multi-agent collaboration platform node to update the anomaly handling strategy library.

[0170] For example, the anomaly handling results are used to record the actual recovery effect after the anomaly is handled, and serve as input for subsequent policy library updates. Specific content may include anomaly recovery time, resource consumption, task replanning scope, and the continuous operating status of the agent after handling. Newly emerging anomaly patterns refer to anomaly types not yet covered in the anomaly handling policy library. The multi-agent collaboration platform node here receives the anomaly handling results and newly emerging anomaly patterns reported by the edge coordination node, and summarizes, classifies, and analyzes their correlations to revise the anomaly level, handling strategy, and recovery conditions.

[0171] In practical applications, when encountering a new, unrecorded anomaly, the edge coordination node first marks the anomaly as a "candidate L2 event to be diagnosed," rather than directly escalating it to L3 level security intervention. Then, based on local observation data reported by multiple neighboring agents surrounding the anomaly agent, it runs a weighted consensus algorithm to reach a quantitative consensus on the nature, magnitude, and scope of the anomaly within a limited time (e.g., 50ms), generating a diagnostic report (e.g., "Type: Location Deviation, Amplitude: 0.15m, Confidence: 92%)." Next, the edge coordination node maps the anomaly to a three-level operation set based on the diagnostic report: if the impact is minor, it is handled automatically at L1 level; if the task can be degraded, it is recombined locally using dynamic slicing capabilities at L2 level; if there is a security risk, it is executed with security intervention at L3 level. After handling, the edge coordination node uploads the entire chain of data to the platform to enrich the digital twin anomaly scenario library, thereby achieving rapid diagnosis, hierarchical processing, and knowledge accumulation of new anomalies, forming a self-learning closed loop.

[0172] In practical implementation, after completing hierarchical anomaly handling, the edge coordination node encapsulates information such as anomaly event identifier, collaborative diagnostic results, executed handling strategies, state comparison data before and after recovery, and handling time into an anomaly handling result message, which is then sent to the multi-agent collaborative platform node via the communication link with the platform node. For novel anomalies identified during the handling process, the edge coordination node also synchronously reports the anomaly triggering conditions, the task context at the time of the anomaly, the type of affected agent, and the reason why the current policy library cannot directly match, so that the platform side can perform pattern recognition and entry supplementation. After receiving the message, the platform node compares the anomaly handling result with historical records, calculates the recovery success rate, rollback count, and resource consumption of different handling strategies in different scenarios, and adjusts the anomaly level threshold, policy triggering conditions, and linkage order accordingly. For newly emerging anomaly patterns, corresponding policy entries are generated and added to the anomaly handling policy library. If necessary, the local cache of the edge node can also be updated synchronously so that subsequent identical or similar anomalies can directly call the updated handling logic.

[0173] This optional approach transmits the results of on-site anomaly handling back to platform nodes, enabling the platform to continuously revise its strategy library based on real-world handling data. This gives the anomaly classification and handling logic self-learning and self-updating capabilities. Simultaneously, newly emerging anomaly patterns can be promptly incorporated into unified management, avoiding the need for manual intervention or temporary rule configuration when similar anomalies recur. This, in turn, improves the robustness, recovery efficiency, and continuous evolution capabilities of the multi-agent collaborative system in complex scenarios.

[0174] In conclusion, Figure 4 The edge coordination node method shown is similar to Figure 2 The platform-side methods shown together form a collaborative closed loop of "global pre-planning - edge real-time scheduling", which realizes efficient and reliable collaboration of multiple agents in high real-time scenarios.

[0175] Figure 5 This is a schematic diagram of the interaction flow of a multi-agent adaptive cooperation method provided in an embodiment of this application. Figure 5 As shown, this multi-agent adaptive cooperation method may include:

[0176] The task interaction application performs the following steps S501:

[0177] S501: Receive the task requirements input by the user through the task interaction application and send them to the multi-agent collaboration platform node.

[0178] The multi-agent collaborative platform node executes the following steps S502~508:

[0179] S502. Pre-build and update the environmental digital twin model of the application scenario to which the target task belongs.

[0180] S503. In advance, perform unified capability modeling on each registered agent, quantify the function of each agent into a multi-dimensional capability vector, and form a global capability library.

[0181] S504. Predefine three levels of anomalies (L1, L2, and L3) and their corresponding handling strategies in advance, based on at least one of the security, reliability, and performance dimensions, and construct an anomaly handling strategy library.

[0182] S505. Use a large language model to parse the user's input task requirements and generate a structured task target for the target task.

[0183] S506. Based on the structured task objectives, the global capability library, and the environmental digital twin model, construct a constraint satisfaction problem model.

[0184] S507. Using Monte Carlo tree search or offline reinforcement learning algorithms, the constraint satisfaction problem model is simulated and deduced in the digital twin model of the environment to generate a pre-sliced ​​solution package for the target task.

[0185] S508. Send the pre-slice scheme package to the edge coordination node.

[0186] Edge coordination nodes perform the following steps S509~512:

[0187] S509: Receive the pre-slice scheme package issued by the multi-agent collaboration platform node.

[0188] S510. Based on real-time sensing information, instantiate the pre-sliced ​​scheme package into the current constraint satisfaction problem model.

[0189] S511. Call the constraint solver to solve the constraint satisfaction problem model within a preset time window and output an executable task slice instruction set.

[0190] S512, Distribute the task slice instruction set to the corresponding intelligent agent for execution.

[0191] The intelligent agent node executes the following steps S513~514:

[0192] S513: Receive and execute the task slice instruction set issued by the edge coordination node.

[0193] S514. Monitor the execution status of the intelligent agent. If an abnormal event occurs, report the observation data of the abnormal intelligent agent according to the instructions.

[0194] Edge coordination nodes perform the following steps S515~518:

[0195] S515, Receive observation data of abnormal agents reported by the agents.

[0196] S516. Consensus processing of observation data based on a weighted consensus protocol to determine collaborative diagnostic results.

[0197] S517. Based on the exception handling strategy library, match the exception level and handling strategy corresponding to the collaborative diagnosis result, and execute the matched handling strategy.

[0198] S518. Report the results of anomaly handling and newly emerging anomaly patterns to the multi-agent collaboration platform node.

[0199] The multi-agent collaborative platform node executes the following steps S519:

[0200] S519. Update the exception handling strategy library based on the results of exception handling and newly emerging exception patterns.

[0201] It should be noted that the specific implementation of steps S501 to S519 can be referred to other embodiments, and will not be repeated here. In practical applications, the multi-agent adaptive cooperation method may include some or all of the above steps, and the embodiments of this application do not impose any limitations.

[0202] The multi-agent adaptive collaboration method provided in this embodiment pre-constructs an environmental digital twin model, a global capability library, and a three-level anomaly policy library on the platform side. It then uses a large language model to parse user requirements, generates pre-sliced ​​solution packages through constraint satisfaction problem modeling and simulation, and finally, edge coordination nodes instantiate these packages using real-time perception information, calling a lightweight solver to output executable instructions within a millisecond-level time window. This achieves a deterministic transformation from user semantic requirements to specific agent actions and a millisecond-level real-time response. Simultaneously, through anomaly monitoring during agent execution, weighted consistency collaborative diagnosis of multi-party observation data, differentiated handling according to L1 / L2 / L3 levels (automatic handling, edge-focused planning, and safety intervention), and feedback of anomaly results to the platform to update the policy library, a complete closed loop of "perception-planning-decision-execution-learning" is formed. This method effectively balances global optimization and local real-time fine-tuning, significantly improving the scheduling efficiency, dynamic adaptability, robustness, and self-healing capability of multi-agent collaboration in high real-time scenarios.

[0203] Next, we will take the collaborative scheduling of multiple AGVs and microservices in a high real-time logistics warehousing scenario as an example. After the warehouse receives the natural language requirements of "moving goods A from shelf X to shelf Y" and new urgent orders, the platform nodes will use a large language model to parse the user's input requirements and convert the natural language task description into a structured task objective of "moving task - goods A - starting point X - ending point Y - priority" to be processed. The platform nodes pre-build a digital twin model of the warehousing scenario. This model includes warehouse layout, shelf locations, charging station locations, aisle occupancy, AGV real-time locations, and inventory status, and is continuously updated as temporary obstacles appear, orders change, and storage locations change. Simultaneously, unified capability modeling is performed on all registered agents, quantifying the functions of the AGV handling robot, inventory management system, and order scheduling microservice into multi-dimensional capability vectors, forming a global capability library. For example, AGV1 can be represented as [speed 1.5m / s, load capacity 20kg, remaining battery 35%, communication range 50m], and the inventory management system microservice can be represented as [task processing rate 100 times / second, resource usage 5% CPU]. The platform nodes also predefine three levels of anomalies (L1, L2, and L3) and corresponding handling strategies according to safety, reliability, and performance dimensions, constructing an anomaly handling strategy library. For example, insufficient AGV battery is classified as L1, path conflict as L2, and communication interruption as L3.

[0204] After obtaining the structured task objective, the platform nodes decompose the objective task into multiple task slices based on the structured task objective. For each task slice, they define allocation object variables and start time variables, establish the domain of the allocation object variables based on the global capability library, and establish the domain of the start time variables based on the environmental digital twin model. Then, they combine the structured task objective, the global capability library, and the environmental digital twin model to construct a constraint set. This constraint set includes at least capability matching constraints, timing constraints, and resource mutual exclusion constraints. For example, in a warehousing instance, it may include constraints such as the required load for the handling task being greater than or equal to the weight of the goods, the AGV's battery level not being less than 20%, two AGVs not being allowed to occupy the same route at the same time, and the goods sorting task being completed before the outbound handling task. This forms a constraint satisfaction problem model composed of decision variables and constraints related to the task slice. Subsequently, the platform nodes use Monte Carlo tree search or offline reinforcement learning algorithms to simulate and deduce the constraint satisfaction problem model in the environmental digital twin model, generating a pre-slicing scheme package for the target task. This pre-slicing scheme package contains the initial allocation information of task slices, initial constraints, and backup schemes that can be called in the case of solution failure. For example, the initial scheme is for AGV1 to execute task slice S1, AGV2 to execute task slice S2, and AGV3 as a backup. The pre-slicing scheme package is then distributed to the edge coordination node.

[0205] After receiving the pre-slicing scheme package from the multi-agent collaboration platform node, the edge coordination node combines it with real-time perception information collected within its preset jurisdiction to instantiate the pre-slicing scheme package into a current constraint satisfaction problem model. Real-time perception information includes the agent's real-time state information, environmental change information, and task change information. In this warehouse, this might manifest as AGV1's battery level dropping from 35% to 30%, a temporary obstacle appearing in the channel where AGV2 is located, or a new high-priority order being inserted into the scheduling queue. When receiving real-time agent state information, the edge coordination node updates the candidate agent set corresponding to the task slice allocation object variables in the constraint satisfaction problem model. For example, it might remove AGV1, whose battery level is continuously decreasing, from the candidate set of some long-distance transport tasks. When detecting one or more of the environmental and task change information, the edge coordination node dynamically adjusts the variable domain and constraints in the model. For example, it might shorten the executable time domain of AGV1, add obstacle avoidance path constraints for AGV2, or insert priority timing constraints corresponding to urgent orders, forming a constraint satisfaction problem model that can be solved at the current moment.

[0206] Furthermore, the edge coordination node inputs the current constraint satisfaction problem model into the constraint solver and performs the solution within a preset time window, for example, 50ms in this scenario. If the constraint solver finds a feasible solution that satisfies all constraints within the time window, the edge coordination node continues to search for the optimal solution in the feasible solution set before the time window ends, according to the preset optimization objective, and generates an executable task slice instruction set based on the optimal solution. If no feasible solution is found within the preset time window, a rollback mechanism is triggered, and the task slice instruction set is generated directly based on the backup solutions contained in the pre-sliced ​​solution package. For the aforementioned warehousing task, the edge coordination node can obtain a task slice instruction set within 50ms to change task S2 to be executed by AGV3, AGV1 to pause its current transport and head to the charging station, and AGV2 to bypass the obstacle area, or directly activate the backup allocation in the pre-sliced ​​solution package if no feasible solution is found. The generated task slice instruction set is issued to the corresponding agent, and each AGV and related microservices carry out collaborative execution according to the task slice allocation results, execution sequence, and related constraints given in the instruction set.

[0207] During the execution of the task slice instruction set, the edge coordination node continuously monitors the execution status of each agent. When an abnormal event is detected, the edge coordination node triggers multiple other agents within its jurisdiction to report observation data on the abnormal agent. Based on a weighted consensus protocol, this observation data undergoes consensus processing, and a collaborative diagnostic result is output. For example, if a communication interruption occurs during AGV3's transport task, the edge coordination node can schedule AGV1 and AGV2 to report AGV3's last position, adjacent channel occupancy status, and task execution progress, and perform consensus diagnosis by combining this with the receipt records in the order scheduling microservice. The edge coordination node then matches the anomaly level and handling strategy corresponding to this collaborative diagnostic result from the anomaly handling strategy library. If the diagnosis corresponds to an L1 level anomaly, a preset recovery procedure is executed or relevant operating parameters are fine-tuned, such as adjusting the speed of AGVs with insufficient power, shortening task paths, or switching charging priorities. If it corresponds to an L2 level anomaly, the relevant task flow is frozen, and the constraint solver is called again to perform local dynamic slicing replanning. After generating a recovery plan, it is issued to the relevant agents, such as freezing the relevant transport flow and reallocating detour paths when there is a path conflict or obstacle blockage. If it corresponds to an L3 level anomaly, an emergency stop command is sent and an alarm is triggered. When the AGV3 communication interruption is diagnosed as L3 level, an emergency stop is issued to its relevant channels and the warehouse manager is notified.

[0208] After anomaly handling is completed, the edge coordination node reports the anomaly handling results and newly emerging anomaly patterns to the multi-agent collaboration platform node. The platform node updates its anomaly handling strategy library accordingly and continues to update the environmental digital twin model based on changes in the application scenario. It also maintains the global capability library by incorporating newly added or changed agent capability information. For this warehouse instance, the platform node can include the AGV3's communication interruption reasons, emergency stop handling records, and task transfer results in the strategy library, and maintain AGV3 communication reliability-related capability information in the global capability library. Simultaneously, it updates the warehouse environment digital twin model based on changes in obstacle distribution, the frequency of emergency order insertion, and charging station occupancy. When a new target task arrives, the platform node regenerates a pre-sliced ​​solution package based on the updated structured task target parsing capabilities, the global capability library, the environmental digital twin model, and the anomaly handling strategy library, and then redistributes it to the corresponding edge coordination node.

[0209] Through the collaborative cooperation of the aforementioned platform nodes, edge coordination nodes, and intelligent agents, physical and virtual intelligent agents can form a closed-loop collaboration around the same target task, thereby reducing the impact of static allocation mismatch, central recalculation lag, and abnormal disturbance propagation, thus improving the real-time adaptability, scheduling stability, and continuous execution capability of intelligent agent collaboration.

[0210] Figure 6 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. Figure 6As shown, the electronic device 60 provided in this embodiment includes at least one processor 601 and a memory 602. Optionally, the device 60 further includes a communication component 603. The processor 601, memory 602, and communication component 603 are connected via a bus 604.

[0211] In a specific implementation, at least one processor 601 executes computer execution instructions stored in memory 602, causing at least one processor 601 to perform the above-described method.

[0212] The specific implementation process of processor 601 can be found in the above method embodiments, and its implementation principle and technical effect are similar. It will not be repeated here.

[0213] In the above embodiments, it should be understood that the processor can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), etc. The general-purpose processor can be a microprocessor or any conventional processor. The steps of the method disclosed in this invention can be directly implemented by a hardware processor, or implemented by a combination of hardware and software modules within the processor.

[0214] The memory may include random access memory (RAM) and may also include non-volatile memory (NVM), such as at least one disk storage device.

[0215] The bus can be an Industry Standard Architecture (ISA) bus, a Peripheral Component Interconnect (PCI) bus, or an Extended Industry Standard Architecture (EISA) bus, etc. Buses can be categorized as address buses, data buses, control buses, etc. For ease of illustration, the buses shown in the accompanying drawings are not limited to a single bus or a single type of bus.

[0216] This application also provides a computer program product, including a computer program that, when executed by a processor, implements the above-described method.

[0217] This application also provides a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, implement the above-described method.

[0218] The aforementioned readable storage medium can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic storage, flash memory, magnetic disk, or optical disk. The readable storage medium can be any available medium accessible to a general-purpose or special-purpose computer.

[0219] An exemplary readable storage medium is coupled to a processor, enabling the processor to read information from and write information to the readable storage medium. Of course, the readable storage medium can also be a component of the processor. The processor and the readable storage medium can reside in an Application Specific Integrated Circuit (ASIC). Alternatively, the processor and the readable storage medium can exist as discrete components in the device.

[0220] The division of units is merely a logical functional division; in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be indirect coupling or communication connection through some interfaces, devices, or units, and may be electrical, mechanical, or other forms.

[0221] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0222] In addition, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit.

[0223] If a function is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or a part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods of the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0224] Those skilled in the art will understand that all or part of the steps of the above-described method embodiments can be implemented by hardware related to program instructions. The aforementioned program can be stored in a computer-readable storage medium. When executed, the program performs the steps of the above-described method embodiments; and the aforementioned storage medium includes various media capable of storing program code, such as ROM, RAM, magnetic disks, or optical disks.

[0225] The above embodiments are merely preferred embodiments provided to fully illustrate this application, and the scope of protection of this application is not limited thereto. Equivalent substitutions or modifications made by those skilled in the art based on this application are all within the scope of protection of this application.

Claims

1. A multi-agent self-adaptive cooperation method, characterized in that, Applied to edge coordination nodes, the method includes: Obtain a pre-slicing scheme package generated for the target task; wherein, the pre-slicing scheme package is used to indicate the initial allocation information and initial constraints of the task slices decomposed from the target task; Based on real-time sensing information, the pre-sliced ​​scheme package is instantiated into the current constraint satisfaction problem model; The constraint solver is invoked to solve the constraint satisfaction problem model within a preset time window, and an executable task slice instruction set is output. The task slice instruction set is sent to the corresponding intelligent agent for execution.

2. The method of claim 1, wherein, The step of obtaining the pre-slice scheme package generated for the target task includes: Receive pre-slicing scheme packages from nodes of the multi-agent collaboration platform; The multi-agent collaborative platform node is used to construct a constraint satisfaction problem model and perform simulation deduction based on the structured task objective, global capability library, and environmental digital twin model of the target task, so as to generate the pre-sliced ​​solution package; the global capability library includes the capability vectors of each agent, and the environmental digital twin model is used to simulate the application scenario to which the target task belongs.

3. The method of claim 1, wherein, The real-time sensing information includes at least one of the following: real-time status information of intelligent agents within a preset jurisdiction, environmental change information, and task change information. The step of instantiating the pre-sliced ​​scheme package into the current constraint satisfaction problem model based on real-time sensing information includes: Based on the real-time status information, update the set of candidate agents for the allocation object variables of the task slices in the constraint-satisfying problem model. Based on the environmental change information and / or the task change information, the variable domain and constraint conditions of the constraint satisfaction problem model are dynamically updated to obtain the current constraint satisfaction problem model.

4. The method of claim 1, wherein, The constraint solver is invoked to solve the constraint satisfaction problem model within a preset time window, and outputs an executable task slice instruction set, including: The constraint satisfaction problem model is input into the constraint solver for solution. If a feasible solution that satisfies all constraints is found within a preset time window, a task slice instruction set is generated based on the feasible solution. If no feasible solution is found within the preset time window, a rollback mechanism is triggered, and a task slicing instruction set is generated based on the backup schemes contained in the pre-slicing scheme package.

5. The method of claim 4, wherein, The step of generating a task slice instruction set based on the feasible solution includes: Before the preset time window ends, according to the preset optimization objective, the optimal solution is found among the feasible solutions, and a task slice instruction set is generated based on the optimal solution.

6. The method according to any one of claims 1-5, characterized in that, The method further includes: During the execution of the task slice instruction set, the execution status of the intelligent agent is monitored; When an abnormal event is detected, it triggers multiple other intelligent agents within a preset jurisdiction to report the observation data of the abnormal intelligent agent; The observed data are processed for consensus based on a weighted consensus protocol to determine the collaborative diagnostic results. Based on the results of the collaborative diagnosis, graded abnormality handling is performed.

7. The method of claim 6, wherein, The step of performing graded abnormality processing based on the collaborative diagnostic results includes: According to the anomaly handling strategy library, match the anomaly level and handling strategy corresponding to the collaborative diagnosis result, and execute the matched handling strategy; The anomaly handling strategy library includes predefined anomaly levels and corresponding handling strategies according to at least one of the following dimensions: security, reliability, and performance. The anomaly levels include L1, L2, and L3. If it is L1, a preset recovery procedure or fine-tuning parameters is executed. If it is L2, the relevant task flow is frozen, and the constraint solver is called to perform local dynamic slice replanning, generate a recovery plan, and issue it. If it is L3, an emergency stop command is sent and an alarm is triggered.

8. The method of claim 7, wherein, The method further includes: The results of anomaly handling and newly emerging anomaly patterns are reported to the multi-agent collaboration platform nodes to update the anomaly handling strategy library.

9. A multi-agent self-adaptive cooperation method, characterized in that, The method, applied to nodes of a multi-agent collaborative platform, includes: Obtain the structured task objectives of the target task to be processed; Based on the structured task objective, global capability library, and environmental digital twin model, a constraint satisfaction problem model is constructed and simulated to generate a pre-slice solution package for the target task. The global capability library includes capability vectors of each agent, and the environmental digital twin model is used to simulate the application scenario to which the target task belongs. The pre-slice solution package is used to indicate the initial allocation information and initial constraints of the task slices decomposed from the target task. The pre-slicing scheme package is distributed to the edge coordination node.

10. The method of claim 9, wherein, The process of obtaining the structured task target for the target task to be processed includes: The user's input needs are parsed using a large language model to generate a structured task objective for the target task.

11. The method of claim 9, wherein, The step involves constructing a constraint satisfaction problem model based on the structured task objective, the global capability library, and the environmental digital twin model, and performing simulation deduction to generate a pre-sliced ​​solution package for the target task, including: Based on the structured task objectives, global capability library, and environmental digital twin model, a constraint satisfaction problem model is constructed; wherein, the constraint satisfaction problem model includes decision variables and constraints related to the task slice; Using Monte Carlo tree search or offline reinforcement learning algorithms, the constraint satisfaction problem model is simulated and deduced in the digital twin model of the environment to generate a pre-sliced ​​solution package for the target task.

12. The method according to any one of claims 9-11, characterized in that, The method further includes at least one of the following: Construct an environmental digital twin model of the application scenario to which the target task belongs, and update the environmental digital twin model according to changes in the application scenario; A unified capability model is performed on each registered agent, and the function of each agent is quantified into a multi-dimensional capability vector to form a global capability library. Based on at least one of the security, reliability, and performance dimensions, a three-level anomaly level (L1, L2, and L3) and corresponding handling strategies are predefined to construct an anomaly handling strategy library.

13. A multi-agent self-adaptive cooperation system, characterized in that, include: A multi-agent collaborative platform node, used to execute the method according to any one of claims 9-12; An edge coordination node for performing the method according to any one of claims 1-8; The intelligent agent execution node is used to receive and execute the task slice instruction set issued by the edge coordination node.

14. An electronic device, comprising: include: Memory, processor; The memory stores computer-executed instructions; The processor executes computer execution instructions stored in the memory, causing the processor to perform the method as described in any one of claims 1-12.

15. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-executable instructions, which, when executed by a processor, are used to implement the method as described in any one of claims 1-12.

Images