A method and system for embodied intelligence multi-agent collaborative work optimization

Abstract

This application provides a method and system for optimizing multi-agent collaborative work using embodied intelligence. The method decomposes the overall collaborative task into multiple atomic subtasks, and publishes the subtasks to be executed and their states through a shared task state publishing module. Each agent evaluates the execution cost and expected benefits of executable atomic subtasks based on its own state and environmental information, using this as a basis for bidding. A bidding strategy function trained using reinforcement learning is used to dynamically allocate subtasks among agents through a distributed market bidding mechanism. When agent execution failure or delay is detected, the global replanning scheme is abandoned, and a local reassignment mechanism is initiated. Only the failed subtask and its directly related tasks are republished and local bidding reassignment is triggered, while the remaining agents continue to execute the original tasks until they complete interface collaboration with the reassigned tasks. This application can achieve dynamic optimization and allocation of agent tasks, thereby improving the overall execution efficiency of collaborative work.

Description

Technical Field

[0001] This application relates to the field of intelligent agent technology, and more specifically, to a method and system for optimizing multi-agent collaborative operations using embodied intelligence. Background Technology

[0002] Embodied intelligence multi-agent systems are widely used in industrial manufacturing, logistics handling, and complex environment operations. Each agent has autonomous perception, decision-making, and execution capabilities, and can collaboratively complete complex tasks. However, during task execution, there are input-output dependencies and resource sharing constraints, requiring real-time coordination and scheduling to ensure the efficient completion of the overall operation and the continuity of the workflow. At the same time, it is necessary to cope with the scheduling complexity brought about by dynamic environmental changes and agent heterogeneity to ensure the stability and scalability of collaborative operations.

[0003] Existing multi-agent collaborative operations typically rely on static task allocation or global scheduling strategies, which cannot dynamically adjust locally to changes in agent execution states or sudden task delays. Static allocation schemes are prone to causing some agents to block tasks or waste resources under conditions of uneven task load or environmental interference. While global replanning methods can adjust task allocation, they require recalculating the entire task plan, resulting in high computational complexity, prolonged response time, and the potential to introduce new coordination conflicts and task backlogs in scenarios with frequent execution interruptions or failures, thus reducing the overall system efficiency and fault tolerance. Therefore, how to achieve dynamic optimization of agent task allocation to improve the overall execution efficiency of collaborative operations has become a challenge for the industry. Summary of the Invention

[0004] This application provides a method and system for optimizing multi-agent collaborative work using embodied intelligence, which can realize dynamic optimization and allocation of agent tasks, thereby improving the overall execution efficiency of collaborative work.

[0005] In a first aspect, this application provides a method for optimizing multi-agent cooperative work using embodied intelligence, comprising the following steps: The overall collaborative task is decomposed into multiple atomic subtasks with clear input-output relationships; Publicize all pending atomic subtasks and their status through the shared task status publishing module; Each agent, based on its own state and environmental information, invokes a task value evaluation network trained by reinforcement learning to evaluate the comprehensive execution cost and expected long-term benefits of one or more executable atomic subtasks, and uses the evaluation results as the basis for bidding. Through a distributed market bidding mechanism, an execution agent is dynamically assigned to each atomic subtask, where each agent bids based on an adaptive bidding strategy function trained by reinforcement learning. When a failure or delay is detected in the execution of an agent, instead of global replanning, a local reallocation mechanism is initiated. Only the atomic subtasks undertaken by the agent that failed or delayed and its directly related tasks are republished to the task board, triggering a new round of bidding and reallocation in the local scope. Other agents will continue to perform their original tasks until they need to interface with the reassigned tasks.

[0006] Preferably, decomposing the overall collaborative task into multiple atomic subtasks with clear input-output relationships specifically includes: Analyze the core objectives and execution process of the overall collaborative task, and identify the key nodes in task execution; Based on the key nodes, multiple initial subtasks are obtained. The initial subtasks are then validated at the granularity level, and initial subtasks with redundant granularity or those that cannot be executed independently are eliminated. For each valid initial subtask, a unique set of input parameters, output criteria, and execution constraints are defined. The input-output dependencies between the initial subtasks are determined, resulting in multiple atomic subtasks with clear input-output relationships. All atomic subtasks can achieve the core objective of the overall collaborative task through collaboration.

[0007] Preferably, publicly disclosing all pending atomic subtasks and their statuses through the shared task status publishing module specifically includes: The shared task status publishing module establishes distributed information interaction nodes, and each distributed information interaction node establishes a two-way communication link with each intelligent agent. Collect parameter information and real-time status of all atomic subtasks to be executed. The parameter information includes input parameter set, output result standard, execution constraints and input-output dependencies. The real-time status includes pending assignment, pending execution, executing, completed, execution failed, and execution delayed. The parameter information and real-time status are standardized and encapsulated, and synchronously disclosed to all intelligent agents through distributed information interaction nodes. The real-time status is updated and disclosed again according to the preset update cycle.

[0008] Preferably, each agent, based on its own state and environmental information, invokes a task value evaluation network trained using reinforcement learning to evaluate the overall execution cost and expected long-term benefits of one or more executable atomic subtasks, and uses the evaluation results as the basis for bidding. Specifically, this includes: Each intelligent agent collects its own status information and environmental information in real time. The self-status information includes computing load, energy reserves, current task progress and task execution capability. The environmental information includes physical environment interference parameters, task execution status of other intelligent agents and shared resource occupancy. Based on the self-state information and environmental information, atomic subtasks that meet the execution constraints are selected as executable atomic subtasks. Call the pre-trained reinforcement learning-based task value evaluation network, input the input parameter set of the executable atomic subtask, its own state information and environment information, and calculate the comprehensive execution cost and expected long-term benefits of each executable atomic subtask; The comprehensive execution cost and expected long-term benefits are normalized to obtain a value assessment value, which is then used as the basis for bidding on the corresponding executable atomic subtasks.

[0009] Preferably, the dynamic allocation of execution agents for each atomic subtask through a distributed market bidding mechanism specifically includes: Establish a distributed bidding node to receive bidding information submitted by each agent for executable atomic subtasks. The bidding information includes agent identifier, target atomic subtask identifier, and corresponding value assessment value. Summarize the bidding information corresponding to each atomic subtask, and select the agents that submit valid bidding information as candidate execution agents; Based on the bidding information, self-state information, and input-output dependencies of the atomic subtasks of the candidate execution agents, calculate the global cooperative fit of each candidate execution agent in executing the atomic subtask; The candidate execution agent with the highest global collaborative adaptability is selected as the target execution agent. The dynamic allocation of atomic subtasks and execution agents is completed, and the allocation results are synchronized to all agents through the shared task state publishing module.

[0010] Preferably, the criteria for determining execution failure or delay are as follows: a preset task execution time limit threshold is used; when the time taken for the agent to execute a task exceeds the task execution time limit threshold, it is determined to be a delay; when the agent reports an execution abnormality, the task output does not meet the preset standard, or the task cannot be completed, it is determined to be an execution failure; wherein, the task execution time limit threshold is preset according to the execution complexity of the atomic subtasks and the time requirements of the overall collaborative task.

[0011] Preferably, other intelligent agents will continue to perform their original tasks until they need to interface with the reassigned tasks, specifically including: Agents that do not exhibit execution anomalies and have not taken on the task of this partial redistribution shall maintain their original task execution rhythm and continue to execute the atomic subtasks they have undertaken that have not exhibited anomalies. Each agent synchronizes its own task execution progress and output results in real time, and monitors whether there is an input-output dependency relationship between the atomic subtask it undertakes and the reassigned task; When the input-output dependency is detected, the execution of the current task is paused, and the reassigned task is waited for to complete the corresponding execution steps and output the results synchronously. After obtaining the valid output results of the reassigned task and completing the interface data synchronization and adaptation, the task itself resumes execution.

[0012] Secondly, this application provides a multi-agent cooperative operation optimization system for embodied intelligence, comprising: The task decomposition module is used to decompose the overall collaborative task into multiple atomic subtasks with clear input-output relationships; The feature processing module is used to expose all atomic subtasks to be executed and their status through the shared task status publishing module; The feature processing module is also used for each agent to call a task value evaluation network trained by reinforcement learning based on its own state and environmental information, to evaluate the comprehensive execution cost and expected long-term benefits of one or more executable atomic subtasks, and to use the evaluation results as the basis for bidding. The feature processing module is also used to dynamically allocate execution agents to each atomic subtask through a distributed market bidding mechanism, wherein each agent bids based on an adaptive bidding strategy function trained by reinforcement learning. The execution module is used to initiate a local reallocation mechanism instead of global replanning when it detects that an agent has failed or is delayed. It only redistributes the atomic subtasks undertaken by the agent that failed or was delayed to the task board and triggers a new round of bidding and reallocation in the local scope. The execution module is also used for other intelligent agents to continue executing the original task until they need to interface with the reassigned task for collaboration.

[0013] Thirdly, this application provides a computer device including a memory and a processor, the memory storing code, and the processor being configured to acquire the code and execute the above-described multi-agent cooperative operation optimization method for embodied intelligence.

[0014] Fourthly, this application provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the above-described multi-agent cooperative operation optimization method for embodied intelligence.

[0015] The technical solutions provided by the embodiments disclosed in this application have the following beneficial effects: This application achieves dynamic optimization of agent task allocation by decomposing the overall collaborative task into atomic subtasks with clear input-output relationships. It combines a shared task state publication module, a reinforcement learning-based task value evaluation network, a distributed market bidding mechanism, an adaptive bidding strategy function, and a local reallocation mechanism. First, by decomposing the collaborative task into atomic subtasks and publicizing their states, each agent can obtain global task information in real time and select executable tasks based on its own state and environmental information, ensuring that task allocation balances individual execution capabilities with global collaborative needs. Second, each agent invokes a reinforcement learning-trained task value evaluation network to assess the comprehensive execution cost and expected long-term benefits of executable atomic subtasks, using the evaluation results as the basis for bidding in a distributed market. The market bidding mechanism generates dynamic bids, enabling intelligent task selection and optimized allocation of global resources. Then, combined with an adaptive bidding strategy function, agents can adjust their bid weights in real time based on task load, environmental interference, and historical bidding data. This allows the task allocation process to dynamically adapt to changes in system state, maximizing load balancing and collaborative efficiency. Simultaneously, when an agent fails or experiences a delay, a local redistribution mechanism locks the abnormal agent's task and its directly related tasks, triggering a new round of bidding and redistribution within a local scope. This avoids global replanning overhead and improves the system's responsiveness and robustness to sudden anomalies. Finally, other agents maintain their original task execution while seamlessly integrating with the redistributed tasks through real-time synchronization and interface adaptation, ensuring task execution continuity and global collaborative consistency. In summary, this application achieves dynamic optimization of agent task allocation through the synergistic effects of task decomposition, value assessment, dynamic bidding, adaptive strategies, and local redistribution, thereby significantly improving the overall execution efficiency of multi-agent collaborative operations. Attached Figure Description

[0016] Figure 1 This is an exemplary flowchart of a multi-agent cooperative operation optimization method for embodied intelligence, according to some embodiments of this application; Figure 2 This is a flowchart illustrating the overall collaborative task decomposition according to some embodiments of this application; Figure 3 This is a flowchart illustrating the determination of a local reallocation mechanism according to some embodiments of this application; Figure 4 This is a schematic diagram of the structure of a multi-agent collaborative work optimization system for embodied intelligence, according to some embodiments of this application; Figure 5 This is a schematic diagram of the structure of a computer device implementing a multi-agent collaborative work optimization method for embodied intelligence, according to some embodiments of this application. Detailed Implementation

[0017] To better understand the technical solution of this application, the technical solution of this application will be described in detail below with reference to the accompanying drawings and specific embodiments.

[0018] refer to Figure 1 The figure is an exemplary flowchart of a multi-agent cooperative operation optimization method for embodied intelligence according to some embodiments of this application. The multi-agent cooperative operation optimization method for embodied intelligence mainly includes the following steps: In step 101, the overall collaborative task is decomposed into multiple atomic subtasks with clear input-output relationships.

[0019] In some embodiments, reference Figure 2 As shown in the figure, this is a flowchart illustrating the overall collaborative task decomposition in some embodiments of this application. In this embodiment, the overall collaborative task is decomposed into multiple atomic subtasks with clear input-output relationships, which can be achieved by the following steps: In step 1011, the core objectives and execution process of the overall collaborative task are analyzed, and the key nodes of task execution are identified; In step 1012, multiple initial subtasks are obtained based on the key node, and the initial subtasks are checked for granularity to eliminate those with redundant granularity or those that cannot be executed independently. In step 1013, a unique set of input parameters, output result standards, and execution constraints are defined for each verified initial subtask. The input-output dependencies between each initial subtask are determined, resulting in multiple atomic subtasks with clear input-output relationships. After all atomic subtasks work together, the core objective of the overall collaborative task can be achieved.

[0020] It should be noted that, in this application, the key nodes refer to nodes that identify the overall collaborative task as insurmountable in time or logical sequence and signify significant state changes; the atomic subtasks refer to the smallest, verified task units that constitute the task execution sequence, possess independent executability and clear boundaries; the execution constraints refer to restrictive rules that must be followed in the execution process of atomic subtasks, involving environmental, resource, time, or security aspects; and the input-output dependencies refer to the association rules used to describe the sequential order and connection logic between different atomic subtasks based on data flow or state flow.

[0021] In practical implementation, firstly, the task planner can parse the received overall collaborative task to clarify its core objective state. Then, using workflow modeling or hierarchical task network analysis methods, the complete execution process to achieve the core objective is deduced and decomposed, drawing possible paths from the initial state to the target state. During this process, intermediate milestones or state transition points that are crucial to task progress and must be completed are identified, such as "materials are in place," "assembly is complete," and "quality inspection has passed." These points are designated as key nodes for task execution, thereby discretizing the continuous process and ultimately defining the state transitions within the process. First, key nodes are identified. Second, for each identified key node, a set of continuous operations between two adjacent key nodes, or a set of necessary operations around a key node, is defined as an initial subtask. A pre-defined granularity verification rule base is then used to verify each initial subtask. Verification includes: determining whether the initial subtask can be further broken down into smaller, still meaningful task units; and determining whether, given execution resources and environment, the initial subtask can independently start and produce intermediate results without relying on real-time collaboration with other initial subtasks. Initial subtasks deemed granularly redundant will be automatically or manually subdivided. For initial subtasks that cannot be executed independently, they are merged with adjacent tasks or their boundaries are redefined. This process aims to ensure the rationality and operability of task units. Ultimately, verified and optimized task units are selected as candidates for atomic subtasks. Then, for each verified initial subtask, formal encapsulation is performed. First, all external supplies required for its startup are defined and organized into a structured set of input parameters. The results that must be produced after successful execution are specified in detail, including the data format, the state of the physical object, or the value of the signal. Quantifiable and verifiable output result standards are set, and the execution constraints that must be followed during execution are defined, such as maximum execution time and specific tool requirements. After defining a single task, including considering safety zone restrictions, the inputs and outputs of all initial subtasks are analyzed. When the set of input parameters required by an initial subtask is entirely or partially derived from the output of another initial subtask, an input-output dependency is established between the two, and the interface specifications for data or state transmission are clarified. After fully defining each initial subtask and establishing their interrelationships, these initial subtasks formally become atomic subtasks that can be recognized, evaluated, and executed by the intelligent agent. All atomic subtasks form an executable task network through their input-output dependencies, and finally, the fully encapsulated and interconnected task units are used as atomic subtasks that can be executed collaboratively.

[0022] It should also be noted that this embodiment decomposes the overall collaborative task into multiple atomic subtasks with clear input-output relationships. This aims to transform the collaborative task into schedulable and verifiable atomic operation units. Its core function is to: establish standardized data interfaces between tasks by clearly defining input-output relationships, decouple complex collaboration into a data flow-based dependency network, and provide a structured foundation for distributed coordination; at the same time, atomic decomposition ensures that each subtask has independent allocatability and verifiability, enabling it to participate in subsequent market bidding and fault-tolerant reallocation, which is a prerequisite for achieving dynamic optimization. This process is essentially a key technical compilation step in converting the task intent into a standardized workflow that the system can execute.

[0023] In step 102, all atomic subtasks to be executed and their status are made public through the shared task status publishing module.

[0024] In some embodiments, exposing all atomic subtasks to be executed and their states through a shared task state publishing module can be achieved by the following steps: The shared task status publishing module establishes distributed information interaction nodes, and each distributed information interaction node establishes a two-way communication link with each intelligent agent. Collect parameter information and real-time status of all atomic subtasks to be executed. The parameter information includes input parameter set, output result standard, execution constraints and input-output dependencies. The real-time status includes pending assignment, pending execution, executing, completed, execution failed, and execution delayed. The parameter information and real-time status are standardized and encapsulated, and synchronously disclosed to all intelligent agents through distributed information interaction nodes. The real-time status is updated and disclosed again according to the preset update cycle.

[0025] It should be noted that the shared task status publishing module in this application refers to a centralized information hub that provides global task status synchronization for all intelligent agents in the system; the distributed information interaction node refers to a peer service endpoint used to realize task status information synchronization and communication coordination among intelligent agents.

[0026] In its specific implementation, the shared task status publishing module employs a message middleware or distributed key-value storage system based on a publish-subscribe model to instantiate one or more distributed information interaction nodes in the network. After each agent starts, it actively establishes a bidirectional communication link based on a transmission control protocol with at least one of the distributed information interaction nodes, according to a pre-configured address or service discovery protocol, thus forming a decentralized information interaction network. Then, the shared task status publishing module periodically or event-triggeredly collects static parameter information of all atomic subtasks and dynamic real-time status reported by the task allocator and executing agents from the central task library or distributed task list maintained by the system. The static parameter information includes the input parameter set, output result standard, execution constraints, and input-output dependencies. The dynamic real-time status includes "pending allocation," "pending execution," "in execution," "completed," "execution failed," and "execution delayed." After collection, the module's built-in wrapper, based on a predefined patterned structure such as JSON,... The schema serializes and combines the parameter information and real-time status of each task, completes standardized encapsulation, and generates a unified format task status data object. This object is pushed to the distributed information interaction node in real time, and the node immediately synchronizes and publishes it to all connected agents that have subscribed to the global status topic through its publish-subscribe mechanism. In addition, a new round of collection, encapsulation and synchronization process is triggered at fixed preset update cycles (e.g., 100 milliseconds) to ensure the continuity and timeliness of status information. Finally, the periodically updated, uniformly formatted task status data object serves as a globally shared basis for collaborative perception and decision-making.

[0027] In step 103, each agent, based on its own state and environmental information, invokes a task value evaluation network trained by reinforcement learning to evaluate the comprehensive execution cost and expected long-term benefits of one or more executable atomic subtasks, and uses the evaluation results as the basis for bidding.

[0028] In some embodiments, each agent, based on its own state and environmental information, invokes a task value evaluation network trained using reinforcement learning to evaluate the overall execution cost and expected long-term benefits of one or more executable atomic subtasks, and uses the evaluation results as the basis for bidding. This can be achieved through the following steps: Each intelligent agent collects its own status information and environmental information in real time. The self-status information includes computing load, energy reserves, current task progress and task execution capability. The environmental information includes physical environment interference parameters, task execution status of other intelligent agents and shared resource occupancy. Based on the self-state information and environmental information, atomic subtasks that meet the execution constraints are selected as executable atomic subtasks. Call the pre-trained reinforcement learning-based task value evaluation network, input the input parameter set of the executable atomic subtask, its own state information and environment information, and calculate the comprehensive execution cost and expected long-term benefits of each executable atomic subtask; The comprehensive execution cost and expected long-term benefits are normalized to obtain a value assessment value, which is then used as the basis for bidding on the corresponding executable atomic subtasks.

[0029] It should be noted that the self-state information in this application is a multi-dimensional dynamic dataset used to describe the available resources, capabilities, and load of the agent during task execution; the environmental information is a set of observational data reflecting the external environmental conditions of the agent and the impact of other agent behaviors on task execution; the executable atomic subtask is used to identify the smallest task unit that can be independently started, executed, and produce effective results under given agent state and environmental conditions; the comprehensive execution cost is an indicator used to measure the resource consumption and cost required for the agent to complete the atomic subtask; the expected long-term benefit is an indicator used to measure the contribution of the agent to future task completion efficiency or overall system benefits after completing the atomic subtask; and the value assessment value is a standardized scalar indicator characterizing the agent's execution priority and bidding reference for a single executable atomic subtask.

[0030] In practice, each agent first collects its own state information periodically or event-triggered through its built-in local state monitoring unit. This information includes computing load data reflecting its computing resource usage, energy reserve data reflecting its sustainable operating capacity, current task progress data reflecting its existing task occupancy, and task execution capability data characterizing its skill set, such as operable device types and maximum load. Simultaneously, the agent collects environmental information through its environmental perception sensors and communication receiving unit. This information includes physical environmental interference parameters affecting its operation (e.g., communication latency, light intensity) and is obtained through the shared task state publishing module. The system collects the task execution status of other agents and their occupancy of shared resources (such as channels and charging stations), ultimately using the real-time collected multi-dimensional dynamic dataset as the raw input for decision-making. Secondly, through a bidirectional communication link, the agent obtains a list of all atomic subtasks in the pending assignment state and their detailed parameter information from the shared task status publishing module. Internally, the agent is configured with a constraint matching filter. This filter iterates through each atomic subtask in the list, comparing its execution constraints with its own state information and environmental information. For example, it checks whether its current energy reserves exceed the estimated energy consumption of the task, whether its current location allows it to reach the task area within the task time limit, and so on. The agent determines whether its skills include the operational capabilities required for the task. Sub-tasks that satisfy all execution constraints are selected, marked as executable, and proceed to the next evaluation stage. Tasks that fail to meet any constraint are immediately excluded. The subset of tasks that pass the initial feasibility test is then selected for in-depth evaluation. The agent then loads its pre-trained task value evaluation network, a neural network model trained using deep reinforcement learning. For each executable sub-task, the agent constructs a feature vector that concatenates and standardizes the task's input parameters, its own state information, and environmental information. The feature vector is input into the task value evaluation network. The forward propagation process of the network will output at least two scalar values: one is the comprehensive execution cost, which quantifies the cost that the agent is expected to pay to perform this task, including time cost, energy consumption, opportunity cost (the inability to perform other tasks due to performing this task), and the impact on its own load; the other is the expected long-term benefit, which quantifies the direct reward that the agent is expected to obtain after successfully completing this task and the potential contribution to the efficiency of future task completion. The network completes this mapping calculation from multi-dimensional features to evaluation quantities through its internal weight parameters. Finally, the two quantified scalars output by the forward propagation of the network are used as a preliminary estimate of the task cost and reward.Finally, the agent is equipped with a value integrator that receives the comprehensive execution cost and expected long-term benefit for each executable atomic subtask. Since these two quantities may have different dimensions and numerical ranges, the value integrator first employs a preset normalization method, such as min-max normalization or Z-score normalization. Then, based on historical data or a preset reasonable range, it maps the comprehensive execution cost and expected long-term benefit to a unified numerical range, for example, between 0 and 1. In a preferred embodiment, the value integrator can use a predefined, learnable weighting formula, such as: Value Assessment = Benefit Weight * Normalized Benefit - Cost Weight *Normalized cost combines normalized costs and benefits into a single scalar, i.e., a value assessment value. This is merely an example and not intended to limit the invention. The higher the value assessment value, the greater the net value the agent perceives in performing the task. This value assessment value is directly used in the subsequent bidding process. The agent will determine its bid based on this value. Generally, the higher the value assessment value, the stronger the bidding intention, and the more competitive the price may be. Ultimately, the combined and normalized net value scalar is used as the direct bidding basis for participating in the distributed market bidding. It should also be noted that the benefit weight and cost weight can be preset based on historical data.

[0031] In step 104, an execution agent is dynamically assigned to each atomic subtask through a distributed market bidding mechanism, wherein each agent bids based on an adaptive bidding strategy function trained by reinforcement learning.

[0032] In some embodiments, dynamically allocating an execution agent to each atomic subtask through a distributed market bidding mechanism can be achieved by the following steps: Establish a distributed bidding node to receive bidding information submitted by each agent for executable atomic subtasks. The bidding information includes agent identifier, target atomic subtask identifier, and corresponding value assessment value. Summarize the bidding information corresponding to each atomic subtask, and select the agents that submit valid bidding information as candidate execution agents; Based on the bidding information, self-state information, and input-output dependencies of the atomic subtasks of the candidate execution agents, calculate the global cooperative fit of each candidate execution agent in executing the atomic subtask; The candidate execution agent with the highest global collaborative adaptability is selected as the target execution agent. The dynamic allocation of atomic subtasks and execution agents is completed, and the allocation results are synchronized to all agents through the shared task state publishing module.

[0033] It should be noted that the distributed bidding node in this application is a network service unit used to receive and manage bidding information for atomic subtasks submitted by multiple agents; the bidding information is a data object used to characterize the agent's willingness to execute a specific atomic subtask and its value judgment; the global collaborative adaptation degree is an indicator that measures the degree of cooperation and matching between the candidate agent and the overall task network when executing atomic subtasks.

[0034] In practice, firstly, one or more distributed bidding nodes are instantiated in the network. Each node is essentially a software service process with a unique network address, responsible for managing the auction process of one or more atomic subtasks. After each agent completes its evaluation of the executable atomic subtask locally, if it decides to participate in the bidding, it sends a structured bidding message to the corresponding task's distributed bidding node according to a predefined communication protocol and data format. This bidding message is a data object, which must contain a string-type "agent identifier" field to uniquely identify the bidding agent, and a string specifying the specific task being bid on. The system includes a "Target Atomic Subtask Identifier" field and a "Value Assessment Value" field, which represents the agent's overall assessment of the task's value. Secondly, when preset bidding deadlines (e.g., a fixed time limit or receiving a sufficient number of bids) are met, the distributed bidding nodes begin processing the allocation of specific atomic subtasks. The nodes first perform a summary operation, reading and parsing all bidding information targeting that task and organizing it into a list. Then, a filtering operation is performed: the nodes verify the validity of each bidding message according to a set of pre-configured rules, including verifying whether the "Agent Identifier" is in the system registry. Registered and with an online status, and whose "value assessment value" is a valid value greater than zero, the agent corresponding to the bidding information whose fields have passed verification is included in the candidate execution agent list. Then, for each candidate execution agent in the list, an adaptation calculation function is called to quantify its global cooperative adaptation. The inputs of this function include: the candidate's bidding information (i.e., value assessment value), the candidate's latest self-state information (such as geographical location and remaining energy) retrieved from the system state database, and the input-output dependencies of the atomic subtask obtained from the task database. The calculation process is disclosed as follows: First First, the value assessment value is normalized to obtain an individual effectiveness score. Second, a state readiness score is calculated based on the individual's own state information, such as a comprehensive assessment of the time cost and energy sufficiency in reaching the task point. Finally, the input-output dependency relationship is analyzed. If the task has a prerequisite task and the candidate is currently performing the prerequisite task, a higher topological synergy score is assigned; otherwise, a baseline score is assigned. The above three scores (all normalized values) are weighted and summed according to preset weights to obtain the final global synergy fit value. The preset weights can be obtained through statistical analysis based on historical data. In this embodiment, the weights are, for example, 0.4, 0.3, and 0.3. This is merely an illustrative example and is not intended to limit the specific scope of the invention. Finally, after the calculation is complete, the node sorts and compares the global cooperative fit values ​​of all candidate execution agents, selecting the candidate with the highest value and officially designating it as the target execution agent for the atomic subtask. Then, the node performs dynamic allocation: on one hand, it sends a task grant confirmation to the target execution agent; on the other hand, the node updates the real-time status of the corresponding atomic subtask to "in execution" by calling the application programming interface provided by the shared task status publishing module, and fills in the identifier of the target execution agent in the "Executor" field of its data record. The shared task status publishing module then broadcasts the global task status update data packet containing the allocation result to all agents according to its publish-subscribe mechanism, synchronizing the optimal agent selection and task binding relationship as system consensus, thus completing the bidding-based dynamic allocation.

[0035] In some embodiments, each agent can make a bid based on an adaptive bidding policy function trained by reinforcement learning, which can be achieved through the following steps: Each agent has a pre-trained adaptive bidding strategy function based on reinforcement learning. The adaptive bidding strategy function takes its own state information, environment information, the value evaluation value of executable atomic subtasks and historical bidding data as input parameters. The adaptive bidding strategy function forms a dynamic bid adjustment rule through reinforcement learning training, and adjusts the bid weight in real time according to its own task load, environmental interference intensity and historical bidding success rate. Based on an adaptive bidding strategy function, combined with the value assessment of executable atomic subtasks, the intelligent agent calculates a bid that meets its own execution capabilities and global coordination needs, completes the bidding operation, and the bid does not exceed the execution threshold corresponding to its own computing power and energy reserves.

[0036] It should be noted that the adaptive bidding strategy function in this application is a strategy model used to generate dynamic bidding decisions based on the agent's own state information, environmental information, task value, and historical bidding data; the dynamic bidding adjustment rule is an operational rule used to guide the agent to adjust the bidding weight in real time to adapt to task load, environmental interference, and historical bidding conditions; and the bidding price is a numerical bid used to express the agent's willingness and ability to execute executable atomic subtasks in a distributed market.

[0037] In practical implementation, firstly, before system deployment, each agent uses a well-known deep reinforcement learning algorithm (such as TensorFlow or PyTorch) to train its adaptive bidding strategy function in a simulated bidding environment. This training process is common knowledge: the agent perceives its state in the simulator, including its own load and environmental interference, and obtains reward signals based on the winning bid and task execution efficiency. Through iterative updates of the algorithm, a neural network model that can output an optimized bid adjustment strategy is finally obtained. Each agent loads this pre-trained model into its local memory during initialization. Secondly, in actual operation, when an agent needs to bid for an executable atomic subtask, it first collects input parameters: these include real-time self-state information read from local sensors, environmental information subscribed from the shared task state publishing module, the task value assessment value calculated by the internal evaluation network, and historical bidding data obtained by querying the local database. Among these, real-time self-state information includes CPU utilization and battery level; environmental information includes network latency data and the location coordinates of collaborating agents. In practical applications, such as the number of successful bids in the last 10 auctions, the agent further calls the loaded adaptive bidding strategy function, i.e., the trained neural network. The feature vector composed of the above parameters is input into the network for forward computation. The network automatically analyzes the current task load, the intensity of environmental interference, and the trend of historical bidding success rate based on the dynamic bidding adjustment rules learned through training, and outputs a bid adjustment coefficient suitable for the current situation. Then, when the agent calculates the bid, it multiplies the obtained adjustment coefficient with the original value assessment value of the task to generate a preliminary bid. To ensure feasibility, the agent performs a rule-based threshold check on the bid. That is, it calculates an execution threshold based on the current real-time computing power load and the remaining power of the energy reserve. For example, the maximum allowed bid = remaining power / estimated energy consumption per unit time of the task. If the preliminary bid exceeds this execution threshold, it is corrected to the value of the execution threshold. Finally, the agent encapsulates the verified bid value, its own identifier, and the task identifier into a standard format message and sends it to the distributed bidding node to complete the bidding operation.

[0038] In step 105, when a failure or delay is detected in the execution of an agent, instead of global replanning, a local reallocation mechanism is initiated. Only the atomic subtasks undertaken by the agent that failed or delayed execution and its directly related tasks are republished to the task board, triggering a new round of bidding and reallocation in the local scope.

[0039] In some embodiments, the criteria for determining execution failure or delay may be implemented using the following steps: A preset task execution time limit threshold is set. When the time taken for the intelligent agent to execute a task exceeds the task execution time limit threshold, it is determined to be a delay. The task execution time limit threshold is preset based on the execution complexity of the atomic sub-tasks and the time requirements of the overall collaborative task. When the agent reports an execution error, the task output does not meet the preset standard, or the task cannot be completed, it is judged as an execution failure.

[0040] In practical implementation, firstly, during system initialization or task decomposition, based on the estimated operation time of each atomic subtask and the overall task deadline, an empirical formula or critical path method is used to calculate and set a specific task execution time limit threshold for each task. During task execution, a simple timer module monitors the process: when the agent starts executing the task, a timer is started, and the real-time time is compared with the preset time limit threshold for that task; once the time exceeds the threshold, the timer module triggers a timeout event, and the system marks the task status as "delayed". For the determination of execution failure, the system uses three rule-based checks in parallel: firstly, the message listening module continuously receives status messages sent by the agent. The system employs three main methods: First, it reports the status of the task. If the report contains a predefined "error" or "abnormal" status code, it is determined that the agent has reported an execution error. Second, after the agent reports that the task has been completed, a result verifier is invoked. This verifier compares the actual output of the task with the output result standard stored in the task definition. If the comparison exceeds the tolerance range, the result is determined to be inconsistent with the preset standard. Third, the system monitors the number of times the agent retryes the same task. If the number of retries exceeds the preset limit or the agent actively sends a "abandon task" request, the task is determined to be unable to be completed. If any of the above three conditions are met, the task status is updated to "execution failed". The triggering of the above determinations is based on preset value comparison and event listening, making the implementation simple and direct.

[0041] In some embodiments, reference Figure 3 As shown in the figure, this is a flowchart illustrating the process of determining the local redistribution mechanism in some embodiments of this application. In this embodiment, the determination of the local redistribution mechanism can be achieved through the following steps: In step 1051, the task execution status of each agent is monitored in real time. When an agent is found to have failed or delayed execution, all atomic subtasks currently undertaken by that agent are locked. In step 1052, the atomic subtasks that the agent has failed or delayed in execution, as well as the directly related tasks that have input-output dependencies on such atomic subtasks, are selected. In step 1053, the atomic subtasks and directly related tasks are removed from the task list of the original executing agent, while the execution status of the remaining atomic subtasks that have not experienced execution anomalies is retained; In step 1054, the status of the atomic subtasks and directly related tasks is updated to pending reallocation, a local reallocation task list is generated, and the local reallocation mechanism is initiated.

[0042] It should be noted that the directly associated task in this application is a task unit that must be processed synchronously due to execution failure or delay and has an input-output dependency relationship with the abnormal atomic subtask; the task list is a management data set used to record all atomic subtasks currently undertaken by the agent and their execution status; the local reassignment task list is a data set used to summarize the abnormal atomic subtasks that need to be reassigned and their associated tasks, and serves as the basis for initiating the local reassignment process.

[0043] In specific implementation, firstly, a state monitoring module is built-in. This module continuously monitors real-time state update events from all atomic subtasks in the shared task state publishing module, and simultaneously receives heartbeats or status messages actively reported by each agent. When the state monitoring module confirms through its criterion logic that an agent has an execution anomaly, it immediately triggers the subsequent processing flow. Specifically, if the criterion logic detects that the task state is marked as "execution failed" or "execution delayed," the module first sends an instruction to the task manager. The task manager, based on the unique identifier of the abnormal agent, queries the global task-agent binding relationship table to find all agents whose executor field matches that agent. Atomic subtask entries with the entity identifier and a status of "in execution" or "pending execution" are temporarily modified or marked as "locked" to prevent accidental operation by other processes during the reassignment process. These temporarily frozen task entries are treated as objects requiring in-depth analysis and screening. Secondly, after locking is completed, a dedicated reassignment analyzer is launched. This analyzer first precisely filters out atomic subtasks with a status of "execution failed" or "execution delayed" from all locked atomic subtasks, marking them as "core abnormal tasks." The analyzer loads the input-output dependency graph generated throughout the task decomposition phase, and for each... The analyzer identifies the "core anomaly task" and searches the graph for all other atomic subtasks that require the output of that core anomaly task as a necessary input to their own parameter set. These tasks are defined as directly related tasks, and the analyzer adds them to the pending task set. This filtering process ensures that subsequent tasks that cannot continue or require resynchronization due to the core task's failure are also included in the processing scope. Ultimately, the core anomaly task and its direct successor tasks are combined into a set of pending tasks that need to be reassigned. Then, after receiving the pending task set provided by the reassignment analyzer, the task manager begins the task attribution cleanup process, traversing the graph... For each atomic subtask in the set, its "executor" field is cleared in the global task-agent binding relationship table, thereby logically removing it from the responsibility list of the original abnormal agent. At the same time, for other atomic subtasks within the locked range but not within the set to be processed, i.e. normal tasks undertaken by the original agent, the task manager removes their "locked" flag, restores their execution status to "running" or "pending execution", and maintains their binding relationship with the original agent unchanged, allowing the original agent to continue to execute these tasks that are not affected by the abnormality. In the end, the normal task responsibility relationship is preserved, and only the association between the abnormal task chain and the original agent is severed.Finally, after completing the attribution cleanup, the Task Manager needs to prepare for relisting and bidding. It updates the real-time status of every atomic subtask in the pending task set to "Pending Assignment." Furthermore, the Task Manager creates a new data list, the Local Reassignment Task List. This list records the identifiers and complete parameter information of all atomic subtasks whose status has been updated to "Pending Assignment," including input parameter sets and output result standards. Generating this list signifies that the analysis and preprocessing of the anomaly's impact scope is complete. The system then submits this Local Reassignment Task List to the shared task status publishing module and the distributed bidding mechanism to trigger the subsequent public and bidding process. Ultimately, this list containing all tasks requiring reassignment serves as the explicit instruction and input to initiate a new round of bidding within a local scope.

[0044] In step 106, the other agents will continue to perform their original tasks until they need to interface with the reassigned tasks.

[0045] In some embodiments, other agents can continue to perform their original tasks until they need to interface with the reassigned tasks. This can be achieved through the following steps: Agents that do not exhibit execution anomalies and have not taken on the task of this partial redistribution shall maintain their original task execution rhythm and continue to execute the atomic subtasks they have undertaken that have not exhibited anomalies. Each agent synchronizes its own task execution progress and output results in real time, and monitors whether there is an input-output dependency relationship between the atomic subtask it undertakes and the reassigned task; When the input-output dependency is detected, the execution of the current task is paused, and the reassigned task is waited for to complete the corresponding execution steps and output the results synchronously. After obtaining the valid output results of the reassigned task and completing the interface data synchronization and adaptation, the task itself resumes execution.

[0046] It should be noted that the input-output dependencies in this application are used to characterize the data or execution order correlation between two or more atomic subtasks in order to determine the constraints of task interface collaboration requirements.

[0047] In practice, firstly, a global task allocation status table is maintained to track the binding relationship between each agent and atomic subtasks. When the local reassignment mechanism is activated, all agents marked as "normal" and not appearing in the task list for this local reassignment are selected based on the status table. A "maintain execution" control command is then sent to these agents. Upon receiving the command, each agent's internal task scheduler continues to drive its actuators (such as robotic arm controllers and mobile chassis drives) to execute the atomic subtasks it is assigned that are in the "in execution" state, according to a preset execution rhythm. The agents report their task progress to the system through periodic heartbeat messages, and the system only monitors the process. Without proactive intervention, the continued execution of the original tasks by normal agents is ultimately the foundation for ensuring the continuity of the overall system workflow. Secondly, each agent integrates a dependency monitor. This monitor, during initialization, loads the global task input-output dependency graph issued by the system. During task execution, the agent synchronizes its current atomic subtask execution progress percentage and intermediate output results in real time by calling the data reporting interface of the shared task status publishing module. Simultaneously, the agent subscribes to all task status change topics in the shared task status publishing module. When it detects a task status update to "in execution after reassignment" or "completed after reassignment," it will detect the change. When the dependency monitor is triggered, it compares the input parameter set of its current task with the output result standard of the reassigned task. If it finds that the input required by its own task is wholly or partially dependent on the output of the reassigned task, it determines that an input-output dependency exists. The agent records this determination result in the local cooperative state variable. Finally, the dependency determination result obtained from the real-time comparison is used as the decision basis for triggering subsequent cooperative operations. Then, when the agent's dependency monitor determines that an input-output dependency exists, it immediately sends a "request pause" signal to the agent's core task execution controller. The task execution controller responds to the signal and saves the complete information of the current atomic subtask. The execution context includes the instruction pointer, register state, and environment snapshot, and controls the actuator to enter a safe pause state, such as the robotic arm maintaining its pose or the mobile robot braking. At the same time, in the shared task state publishing module, the agent registers a state listening callback for the specific reassigned task it depends on. The agent enters a blocking wait loop, which periodically checks whether the callback has been triggered and whether a valid output result data notification has been received. This waiting process continues until the state of the dependent reassigned task becomes "completed" and its output is verified. Finally, the safe pause of the current task and the waiting for the completion event of the dependent task are used as a collaborative waiting state to ensure the correct order of the job logic.Finally, the agent obtains the valid output result data packet of the reassigned task it depends on through the designated data query interface provided by the shared task status publishing module. The interface adapter inside the agent parses, converts the format, and verifies the range of the output result according to the data format and type requirements defined by the input parameter set of its current atomic subtask, completing data adaptation. After successful adaptation, the interface adapter writes the processed data into the corresponding input variables of the task execution context. Subsequently, the task execution controller loads the previously saved execution context and sends a "resume execution" command to the executor, continuing the execution of the interrupted atomic subtask from the precise pause point. Simultaneously, the agent updates its own status to "in execution" and resumes progress synchronization. Ultimately, the successful receipt and adaptation of the external output result constitutes the continuation of the task's execution as the action to complete this interface collaboration and drive the overall process forward.

[0048] On the other hand, in some embodiments, this application provides a multi-agent cooperative work optimization system for embodied intelligence, with reference to... Figure 4 The figure is a schematic diagram of the structure of a multi-agent cooperative task optimization system for embodied intelligence according to some embodiments of this application. The multi-agent cooperative task optimization system 400 for embodied intelligence includes: a task decomposition module 401, a feature processing module 402, and an execution module 403, which are described below: The task decomposition module 401 is used to decompose the overall collaborative task into multiple atomic subtasks with clear input-output relationships; The feature processing module 402 is used to expose all atomic subtasks to be executed and their status through the shared task status publishing module; The feature processing module 402 is also used for each agent to call a task value evaluation network trained by reinforcement learning based on its own state and environmental information, to evaluate the comprehensive execution cost and expected long-term benefits of one or more executable atomic subtasks, and to use the evaluation results as the basis for bidding. The feature processing module 402 is also used to dynamically allocate execution agents to each atomic subtask through a distributed market bidding mechanism, wherein each agent bids based on an adaptive bidding strategy function trained by reinforcement learning. The execution module 403 is used to, when a failure or delay is detected in the execution of an agent, not to perform global replanning, but to start a local reallocation mechanism, only to republish the atomic subtasks undertaken by the agent that failed or delayed in execution and its directly related tasks to the task board, and trigger a new round of bidding and reallocation in the local scope. The execution module 403 is also used so that other intelligent agents can continue to execute the original task until they need to interface with the reassigned task.

[0049] In addition, this application also provides a computer device, the computer device including a memory and a processor, the memory storing code, the processor being configured to acquire the code and execute the above-described multi-agent cooperative operation optimization method for embodied intelligence.

[0050] In some embodiments, reference Figure 5 The figure is a schematic diagram of the structure of a computer device implementing a multi-agent cooperative work optimization method for embodied intelligence, according to some embodiments of this application. The multi-agent cooperative work optimization method for embodied intelligence in the above embodiments can be implemented through... Figure 5 The computer device shown is used to implement this, and the computer device 500 includes at least one processor 501, a communication bus 502, a memory 503, and at least one communication interface 504.

[0051] Processor 501 can be a general-purpose central processing unit (CPU) or an application-specific integrated circuit (ASIC).

[0052] The communication bus 502 can be used to transmit information between the aforementioned components.

[0053] Memory 503 may be a read-only memory (ROM) or other type of static storage device capable of storing static information and instructions, random access memory (RAM) or other type of dynamic storage device capable of storing information and instructions, or electrically erasable programmable read-only memory (EEPROM), compact disc read-only memory (CDROM) or other optical disc storage, optical disc storage (including compressed optical discs, laser discs, optical discs, digital versatile optical discs, Blu-ray discs, etc.), magnetic disks or other magnetic storage devices, or any other medium capable of carrying or storing desired program code in the form of instructions or data structures and accessible by a computer, but not limited thereto. Memory 503 may exist independently and be connected to processor 501 via communication bus 502. Memory 503 may also be integrated with processor 501.

[0054] The memory 503 stores program code for executing the scheme of this application, and its execution is controlled by the processor 501. The processor 501 executes the program code stored in the memory 503. The program code may include one or more software modules. The multi-agent cooperative operation optimization method for embodied intelligence in the above embodiments can be implemented by the processor 501 and one or more software modules in the program code in the memory 503.

[0055] Communication interface 504 uses any transceiver-like device to communicate with other devices or communication networks, such as Ethernet, radio access network (RAN), wireless local area networks (WLAN), etc.

[0056] In a specific implementation, as one example, a computer device may include multiple processors, each of which may be a single-core (single CPU) processor or a multi-core (multi CPU) processor. Here, a processor may refer to one or more devices, circuits, and / or processing cores used to process data (e.g., computer program instructions).

[0057] The aforementioned computer device can be a general-purpose computer device or a special-purpose computer device. In specific implementations, the computer device can be a desktop computer, a portable computer, a network server, a handheld digital assistant (PDA), a mobile phone, a tablet computer, a wireless terminal device, a communication device, or an embedded device. This application does not limit the type of computer device.

[0058] In addition, this application also provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the above-described multi-agent cooperative operation optimization method for embodied intelligence.

[0059] Although preferred embodiments of this application have been described, those skilled in the art, upon learning the basic inventive concept, can make other changes and modifications to these embodiments. Therefore, the appended claims are intended to be interpreted as including the preferred embodiments as well as all changes and modifications falling within the scope of this application.

[0060] Obviously, those skilled in the art can make various modifications and variations to this application without departing from the spirit and scope of this application. Therefore, if such modifications and variations fall within the scope of the claims of this application and their equivalents, this application also intends to include such modifications and variations.

Claims

1. A method for optimizing multi-agent cooperative work using embodied intelligence, characterized in that, include: The overall collaborative task is decomposed into multiple atomic subtasks with clear input-output relationships; Publicize all pending atomic subtasks and their status through the shared task status publishing module; Each agent, based on its own state and environmental information, invokes a task value evaluation network trained by reinforcement learning to evaluate the comprehensive execution cost and expected long-term benefits of one or more executable atomic subtasks, and uses the evaluation results as the basis for bidding. Through a distributed market bidding mechanism, an execution agent is dynamically assigned to each atomic subtask, where each agent bids based on an adaptive bidding strategy function trained by reinforcement learning. When a failure or delay is detected in the execution of an agent, instead of global replanning, a local reallocation mechanism is initiated. Only the atomic subtasks undertaken by the agent that failed or delayed and its directly related tasks are republished to the task board, triggering a new round of bidding and reallocation in the local scope. Other agents will continue to perform their original tasks until they need to interface with the reassigned tasks.

2. The method as described in claim 1, characterized in that, The overall collaborative task is broken down into multiple atomic subtasks with clear input-output relationships, specifically including: Analyze the core objectives and execution process of the overall collaborative task, and identify the key nodes in task execution; Based on the key nodes, multiple initial subtasks are obtained. The initial subtasks are then validated at the granularity level, and initial subtasks with redundant granularity or those that cannot be executed independently are eliminated. For each valid initial subtask, a unique set of input parameters, output criteria, and execution constraints are defined. The input-output dependencies between the initial subtasks are determined, resulting in multiple atomic subtasks with clear input-output relationships. All atomic subtasks can achieve the core objective of the overall collaborative task through collaboration.

3. The method as described in claim 1, characterized in that, The shared task status publishing module publicly discloses all pending atomic subtasks and their statuses, including: The shared task status publishing module establishes distributed information interaction nodes, and each distributed information interaction node establishes a two-way communication link with each intelligent agent. Collect parameter information and real-time status of all atomic subtasks to be executed. The parameter information includes input parameter set, output result standard, execution constraints and input-output dependencies. The real-time status includes pending assignment, pending execution, executing, completed, execution failed, and execution delayed. The parameter information and real-time status are standardized and encapsulated, and synchronously disclosed to all intelligent agents through distributed information interaction nodes. The real-time status is updated and disclosed again according to the preset update cycle.

4. The method as described in claim 1, characterized in that, Each agent, based on its own state and environmental information, invokes a task value evaluation network trained using reinforcement learning to assess the overall execution cost and expected long-term benefits of one or more executable atomic subtasks, and uses the evaluation results as the basis for bidding. Specifically, this includes: Each intelligent agent collects its own status information and environmental information in real time. The self-status information includes computing load, energy reserves, current task progress and task execution capability. The environmental information includes physical environment interference parameters, task execution status of other intelligent agents and shared resource occupancy. Based on the self-state information and environmental information, atomic subtasks that meet the execution constraints are selected as executable atomic subtasks. Call the pre-trained reinforcement learning-based task value evaluation network, input the input parameter set of the executable atomic subtask, its own state information and environment information, and calculate the comprehensive execution cost and expected long-term benefits of each executable atomic subtask; The comprehensive execution cost and expected long-term benefits are normalized to obtain a value assessment value, which is then used as the basis for bidding on the corresponding executable atomic subtasks.

5. The method as described in claim 1, characterized in that, Through a distributed market bidding mechanism, an execution agent is dynamically allocated to each atomic subtask, specifically including: Establish a distributed bidding node to receive bidding information submitted by each agent for executable atomic subtasks. The bidding information includes agent identifier, target atomic subtask identifier, and corresponding value assessment value. Summarize the bidding information corresponding to each atomic subtask, and select the agents that submit valid bidding information as candidate execution agents; Based on the bidding information, self-state information, and input-output dependencies of the atomic subtasks of the candidate execution agents, calculate the global cooperative fit of each candidate execution agent in executing the atomic subtask; The candidate execution agent with the highest global collaborative adaptability is selected as the target execution agent. The dynamic allocation of atomic subtasks and execution agents is completed, and the allocation results are synchronized to all agents through the shared task state publishing module.

6. The method as described in claim 1, characterized in that, The criteria for determining execution failure or delay are as follows: a preset task execution time limit threshold is used. When the time taken for the agent to execute a task exceeds the task execution time limit threshold, it is determined to be a delay. When the agent reports an execution abnormality, the task output does not meet the preset standard, or the task cannot be completed, it is determined to be an execution failure. The task execution time limit threshold is preset based on the execution complexity of the atomic subtasks and the time requirements of the overall collaborative task.

7. The method as described in claim 1, characterized in that, Other agents will continue to perform their original tasks until they need to interface with the reassigned tasks, specifically including: Agents that do not exhibit execution anomalies and have not taken on the task of this partial redistribution shall maintain their original task execution rhythm and continue to execute the atomic subtasks they have undertaken that have not exhibited anomalies. Each agent synchronizes its own task execution progress and output results in real time, and monitors whether there is an input-output dependency relationship between the atomic subtask it undertakes and the reassigned task; When the input-output dependency is detected, the execution of the current task is paused, and the reassigned task is waited for to complete the corresponding execution steps and output the results synchronously. After obtaining the valid output results of the reassigned task and completing the interface data synchronization and adaptation, the task itself resumes execution.

8. A multi-agent collaborative work optimization system for embodied intelligence, characterized in that, include: The task decomposition module is used to decompose the overall collaborative task into multiple atomic subtasks with clear input-output relationships; The feature processing module is used to expose all atomic subtasks to be executed and their status through the shared task status publishing module; The feature processing module is also used for each agent to call a task value evaluation network trained by reinforcement learning based on its own state and environmental information, to evaluate the comprehensive execution cost and expected long-term benefits of one or more executable atomic subtasks, and to use the evaluation results as the basis for bidding. The feature processing module is also used to dynamically allocate execution agents to each atomic subtask through a distributed market bidding mechanism, wherein each agent bids based on an adaptive bidding strategy function trained by reinforcement learning. The execution module is used to initiate a local reallocation mechanism instead of global replanning when it detects that an agent has failed or is delayed. It only redistributes the atomic subtasks undertaken by the agent that failed or was delayed to the task board and triggers a new round of bidding and reallocation in the local scope. The execution module is also used for other intelligent agents to continue executing the original task until they need to interface with the reassigned task for collaboration.

9. A computer device comprising a memory and a processor, the memory storing code, characterized in that, The processor is configured to acquire the code and execute the multi-agent cooperative operation optimization method for embodied intelligence as described in any one of claims 1 to 7.

10. A computer-readable storage medium storing a computer program, characterized in that, When the computer program is executed by the processor, it implements the multi-agent cooperative operation optimization method for embodied intelligence as described in any one of claims 1 to 7.

Images