Multi-body intelligent agent hierarchical memory collaborative self-evolution method

Abstract

The application relates to the technical field of embodied intelligence, and specifically discloses a multi-embodied intelligent agent layered memory collaborative self-evolution method. The method first performs layered memory distillation on an embodied perception decision log stream through kinematic residual constraint, counterfactual causal confidence calibration and causal structure similarity clustering to obtain kinematic error correction memory, a causal chain confidence memory set and a causal structure constraint template. Then, the agent memory maturity is calculated based on causal chain confidence aggregation. The causal memory and the constraint template are screened and fused based on the maturity to construct a cross-task causal migration graph. Then, the maturity is used for gradient task allocation of the multi-agent, and a differentiated scheduling instruction and a cross-task prior constraint template are matched and generated in the migration graph. Each agent executes the task according to the scheduling instruction and the prior template, performs motion compensation by using the error correction memory, and forms a closed-loop iteration after the perception decision data is adaptively adjusted and distilled to a deep depth.

Description

Technical Field

[0001] This application relates to the field of embodied intelligence technology, and more specifically, to a multi-embodied intelligent agent hierarchical memory collaborative self-evolution method. Background Technology

[0002] With the large-scale deployment of embodied intelligence technology in complex scenarios such as commercial services and industrial inspections, multiple embodied agents need to continuously accumulate task execution experience and achieve autonomous iterative improvement of capabilities through long-term continuous operation. This places higher demands on the memory management efficiency, cross-task generalization ability, and multi-agent collaborative scheduling accuracy of the agents. However, existing technologies generally adopt a full log storage strategy at the memory management level, without applying differentiated structured purification processing to perceptual motion data and decision-making call data at different levels. This results in high memory noise and high storage overhead. When large language models call historical memory to assist in skill decision-making, they are prone to introducing invalid information and amplifying the skill call illusion. Agents cannot achieve autonomous capability evolution through task accumulation and must rely on manual periodic optimization of model parameters. In terms of multi-agent collaborative scheduling, existing solutions usually only match and assign tasks based on the agent role type, completely ignoring the actual decision-making ability differentiation caused by the difference in task experience accumulation between different agents of the same role. This results in newly joined agents with little experience being assigned tasks of equal complexity to mature agents with a large amount of high-quality decision-making experience, leading to a high overall task failure rate and a serious mismatch of computing resources. More critically, when faced with entirely new task types they have never performed before, existing agents lack cross-task experience transfer mechanisms. Their existing heterogeneous task history experience cannot be effectively reused, forcing them to make random, exploratory decisions from scratch, severely limiting their generalization ability and evolutionary potential. Furthermore, even if a topological graph for cross-task experience reuse is constructed, if the retrieval criteria for reusable historical experience subgraphs for new tasks rely solely on the node coverage between candidate subgraphs and the new task's skill sequence, ignoring the historical verification reliability information carried by the migration paths in the graph, then when multiple candidate subgraphs have similar scores in the node overlap dimension, a weakly reliable subgraph with insufficiently verified internal migration paths may be selected. Injecting the constraints carried by such subgraphs as priors into the decision-making process can cause the agent to fail during skill chain switching due to weak paths.

[0003] Therefore, an optimized multi-agent hierarchical memory collaborative self-evolution scheme is desired. Summary of the Invention

[0004] To address the aforementioned technical problems, this application is proposed. Embodiments of this application provide a multi-agent hierarchical memory collaborative self-evolution method.

[0005] According to one aspect of this application, a multi-agent hierarchical memory collaborative self-evolution method is provided, comprising: Step 1: Through kinematic residual constraints, counterfactual causal confidence calibration, and causal structure similarity clustering, hierarchical memory distillation is performed on the embodied perception decision log stream to obtain kinematic error correction memory, causal chain confidence memory set, and causal structure constraint template. Step 2: Based on the confidence of each causal chain in the causal chain confidence memory set after counterfactual calibration, aggregate and measure it in an endogenous way without artificially preset weights to obtain the agent's memory maturity. Step 3: Based on the agent's memory maturity, dynamically reconstruct the cross-task causal transfer network graph by combining the causal chain confidence memory set and the causal structure constraint template to obtain the cross-task causal transfer graph. Step 4: Based on the agent's memory maturity, perform gradient task allocation for multiple agents, and perform maximum overlap subgraph matching on the new task skill sequence in the cross-task causal transfer graph to obtain differentiated scheduling instructions and cross-task prior constraint templates. Step 5: Each agent executes the task according to the differentiated scheduling instructions and cross-task prior constraint template, and uses kinematic error correction memory for motion compensation. The newly generated perception and decision data is encapsulated into an embodied perception and decision log stream. The distillation depth is adaptively adjusted based on the agent's memory maturity and then returned to Step 1 to form a closed loop iteration.

[0006] Compared with existing technologies, this application provides a multi-agent hierarchical memory collaborative self-evolution method. Firstly, it introduces three differentiated distillation mechanisms—kinematic residual constraints, counterfactual causal confidence calibration, and causal structure similarity clustering—to perform hierarchical memory purification of the embodied perception decision log stream, fundamentally solving the problems of high noise and loss of effective information in full-scale storage. Secondly, based on the causal chain confidence produced by distillation, it intrinsically aggregates and calculates the agent's memory maturity, eliminating the subjectivity of manually preset weights and achieving accurate quantification of the agent's true decision-making ability. This, in turn, allows for... Based on this, a gradient-based task allocation is performed for multiple agents to solve the resource mismatch problem in the role matching scheduling mode. Secondly, a cross-task causal migration graph is constructed based on maturity gating, enabling high-quality historical experience to be reused across heterogeneous tasks and breaking through the generalization bottleneck of decision-making from scratch. At the same time, a joint matching mechanism of migration path bottleneck reliability and node overlap is introduced in the graph subgraph retrieval stage to avoid selecting weakly reliable subgraphs by a single coverage criterion, which would lead to execution failure. Finally, the distillation, maturity, scheduling and execution data are fed back to form a closed loop iteration to achieve multi-agent collaborative self-evolution. Attached Figure Description

[0007] The above and other objects, features, and advantages of this application will become more apparent from the more detailed description of the embodiments of this application in conjunction with the accompanying drawings. The drawings are provided to further illustrate the embodiments of this application and form part of the specification. They are used together with the embodiments of this application to explain this application and do not constitute a limitation thereof. In the drawings, the same reference numerals generally represent the same components or steps.

[0008] Figure 1 This is a flowchart of a multi-embodied intelligent agent hierarchical memory collaborative self-evolution method according to an embodiment of this application; Figure 2 This is a schematic diagram of the data flow of the multi-embodied intelligent agent hierarchical memory collaborative self-evolution method according to an embodiment of this application; Figure 3 This is a flowchart of step three of the multi-embodied intelligent agent hierarchical memory collaborative self-evolution method according to an embodiment of this application; Figure 4 This is a flowchart of step four of the hierarchical memory collaborative self-evolution method for multiple embodied intelligent agents according to an embodiment of this application; Figure 5 This is a flowchart of step 4.2 of the multi-embodied intelligent agent hierarchical memory collaborative self-evolution method according to an embodiment of this application. Detailed Implementation

[0009] Hereinafter, exemplary embodiments according to this application will be described in detail with reference to the accompanying drawings. Obviously, the described embodiments are merely some embodiments of this application, and not all embodiments of this application. It should be understood that this application is not limited to the exemplary embodiments described herein.

[0010] Existing embodied agent systems face several technical challenges, including rampant noise in full memory storage hindering autonomous evolution, resource misallocation due to role-based matching in multi-agent scheduling neglecting individual ability differences, weak generalization ability for new tasks due to the inability to effectively transfer and reuse historical experience across tasks, and execution failures caused by weak verification priors introduced during experience transfer retrieval due to neglecting path reliability. To address these issues, this application proposes a hierarchical memory-based collaborative self-evolution method for multiple embodied agents. In implementation, the scheme first performs three-layer differentiated memory distillation on the embodied perception decision log stream. The cerebellar layer calculates physical residuals based on a kinematic forward model and filters redundant motion data, retaining only abnormal deviation correction parameters. The cerebral layer calibrates the failure probability of the positive decision causal chain and prunes accidental success paths by generating counterfactual alternative paths in batches. The central layer performs clustering based on the Jaccard structural similarity of the causal chain skill subsequences and extracts common constraint templates. Subsequently, the system uses the high-confidence causal chain confidence produced by distillation as the sole data source and intrinsically calculates the memory maturity index of each agent through negative log-cumulative and hyperbolic tangent mappings. Based on this, agents whose maturity reaches a high-order threshold publish their causal memories to the global cross-task causal transfer graph, and the system shares skills between heterogeneous causal chains. The matching of subsequences establishes migration edges and assigns them with the geometric mean of confidence, forming a continuously expanding empirical topology network. When a new task is introduced, the system performs differentiated task assignment and weighted allocation of computing power and bandwidth to multiple agents based on maturity gradient. At the same time, the optimal matching subgraph is retrieved in the migration graph by multiplicative joint score of node intersection-union ratio overlap and migration path bottleneck reliability. High-confidence causal logic is extracted from it and encapsulated into a priori constraint template and sent to the execution layer. Finally, each agent completes the physical task execution under the guidance of prior constraints and kinematic error compensation. The newly generated multi-source sensor data is timestamped and encapsulated into a standardized log stream. The distillation depth level is adaptively determined based on maturity and then returned to the distillation inlet to drive the next iteration, forming a self-evolving closed-loop flywheel with continuously growing capabilities.

[0011] Figure 1 This is a flowchart of a multi-embodied intelligent agent hierarchical memory collaborative self-evolution method according to an embodiment of this application. Figure 2 A schematic diagram of the data flow of the multi-embodied intelligent agent hierarchical memory cooperative self-evolution method according to embodiments of this application is shown below. Figure 1 and Figure 2As shown, the multi-embodied agent hierarchical memory collaborative self-evolution method according to an embodiment of this application includes: Step 1, performing hierarchical memory distillation on the embodied perception decision log stream through kinematic residual constraints, counterfactual causal confidence calibration, and causal structure similarity clustering to obtain kinematic error correction memory, causal chain confidence memory set, and causal structure constraint template; Step 2, based on the confidence of each causal chain in the causal chain confidence memory set after counterfactual calibration, performing aggregation measurement in an endogenous manner without artificially preset weights to obtain the agent's memory maturity; Step 3, based on the agent's memory maturity, performing... Step 4: Dynamically reconstruct the cross-task causal transfer network graph to obtain the cross-task causal transfer graph; Step 5: Based on the agent's memory maturity, perform gradient task allocation for multiple agents, and perform maximum overlap subgraph matching on the new task skill sequence in the cross-task causal transfer graph to obtain differentiated scheduling instructions and cross-task prior constraint templates; Step 6: Each agent executes the task according to the differentiated scheduling instructions and cross-task prior constraint templates, and uses kinematic error correction memory for motion compensation, and encapsulates the newly generated perception decision data into an embodied perception decision log stream, and after adaptively adjusting the distillation depth based on the agent's memory maturity, it flows back to Step 1 to form a closed loop iteration.

[0012] Specifically, in step one, hierarchical memory distillation is performed on the embodied perception decision log stream through kinematic residual constraints, counterfactual causal confidence calibration, and causal structure similarity clustering to obtain kinematic error correction memory, causal chain confidence memory set, and causal structure constraint template. It is worth noting that the embodied perception decision log stream includes odometry data, LiDAR point cloud data, wheel speed control command data, and task decision call record data. It is understandable that, due to the massive amounts of perception motion data and decision call records generated during the long-term continuous operation of the embodied agent, storing all of these raw logs as memory would not only incur huge storage costs, but also introduce a large amount of redundant noise data into subsequent memory calls, amplifying the skill call illusion of the language model, causing the agent's decision quality to continuously degrade and preventing autonomous evolution of its capabilities. Therefore, in the technical solution of this application, hierarchical memory distillation is performed on the embodied perception decision log stream through kinematic residual constraints, counterfactual causal confidence calibration, and causal structure similarity clustering to obtain kinematic error correction memory, causal chain confidence memory set, and causal structure constraint template. This allows for the application of differentiated domain prior constraints to log data at different levels, accurately eliminating physically redundant data and accidental success paths, and retaining only structured memories with real correction value and highly deterministic causal semantics. This significantly compresses memory storage while fully preserving key correction information and reusable decision logic, providing a high-purity data foundation for subsequent agent maturity calculations, cross-task experience transfer, and collaborative scheduling, thus eliminating the interference of memory noise on the decision system at its source.

[0013] More specifically, in the embodiments of this application, step one includes: step 1.1, based on the kinematic forward model parameters, performing cerebellar layer error incremental distillation on the odometer data and wheel speed control command data in the embodied perception decision log stream based on kinematic physical constraints to obtain kinematic error correction memory; step 1.2, using alternative skills in the skill base, performing failure probability calibration and low-confidence path pruning on the positive causal chain of task decision call record data in the embodied perception decision log stream to obtain a causal chain confidence memory set; step 1.3, based on the subsequence overlap threshold, performing structural similarity clustering and common subsequence extraction on the continuous skill subsequences of each causal chain in the causal chain confidence memory set to obtain a causal structure constraint template.

[0014] Specifically, in a particular example of this application, the scenario is that six embodied intelligent agents deployed in a commercial complex perform tour guiding, security and explanation tasks. Each intelligent agent runs continuously for 30 days and generates a total of 1.2 million original perception and decision logs. The embodied perception and decision log stream includes odometer data, LiDAR point cloud data, wheel speed control command data and task decision call record data. The system performs three stages of processing on the log stream in sequence: cerebellar error increment distillation, cerebral counterfactual causal chain distillation, and central causal structure similarity clustering distillation.

[0015] Specifically, firstly, based on the kinematic forward model parameters, the system performs cerebellar layer error incremental distillation on the embodied perception decision log stream's odometry data and wheel speed control command data, based on kinematic physical constraints, to obtain kinematic error correction memory. The specific implementation process is as follows: Odometry data and wheel speed control command data, time-aligned, are read sequentially from the embodied perception decision log stream according to a unified time reference from a global hardware synchronization clock source. The odometry data records the agent's actual pose state at each time step, including two-dimensional plane coordinates and heading angle, while the wheel speed control command data records the angular velocity command values ​​issued to the left and right drive wheels at the same time step. The system loads the kinematic forward model parameters pre-obtained through an offline calibration program. These parameters include rigid geometric parameters such as wheel diameter, wheelbase, and transmission ratio. These parameters are used to construct a differential drive kinematic forward physical mapping model. For the i-th time step, the system substitutes the wheel speed control command data of the current time step into the kinematic forward physical mapping model, and performs forward calculations to obtain the theoretically predicted pose state that the agent should reach at that time step under ideal error-free conditions. Subsequently, the system subtracts the actual motion pose state represented by the odometer data from the theoretically predicted pose state component by component to obtain the kinematic residual vector for that time step. This residual vector contains planar position deviation components and heading angle deviation components. The system calculates the Euclidean L2 norm of this kinematic residual vector and compares the calculation result with a preset kinematic allowable deviation threshold: when the L2 norm exceeds the threshold, it indicates that the actual motion behavior of the current time step deviates from the normal fluctuation range allowed by physical kinematic laws, indicating a systematic hardware deviation or abnormal operating condition. The system sets the corresponding filter identifier to valid and retains the residual record; when the L2 norm does not exceed the threshold, it indicates that the motion data of the current time step is within the physically reasonable range and belongs to normal operating redundant data. The system sets the corresponding filter identifier to invalid and discards the entry. After filtering through the entire log entry, the system collects all kinematic residual vectors with valid filter identifiers, arranges them by timestamp, and encapsulates them in a structured manner as a kinematic error correction memory. This memory only contains abnormal deviation parameters with real physical correction value. The core calculation of the above-mentioned cerebellar error increment distillation process is expressed as follows: in, The kinematic residual vector calculated at the i-th time step has the same dimension as the pose state space of the agent and includes planar position deviation and heading angle deviation components. The actual motion pose state observation value extracted from the odometry data at the i-th time step; This is a physical mapping function for differential drive kinematic forward modeling established based on kinematic forward model parameters. Its inputs are model parameters and control variables, and its output is the theoretically predicted pose state. The set of kinematic forward model parameters obtained in advance through offline calibration includes rigid geometric parameters such as wheel diameter, wheel track, and transmission ratio. The left and right drive wheel angular velocity control inputs extracted from the wheel speed control command data at the i-th time step; This is a Boolean filter identifier. A value of 1 indicates that the abnormal residuals of this time step are retained, and a value of 0 indicates that the redundant data of this time step is filtered out. The kinematic residual vector The Euclidean L2 norm is used to measure the overall deviation of the actual motion state from the theoretically predicted state. The preset kinematic deviation threshold is set based on the inherent accuracy indicators and operating conditions of the intelligent agent chassis hardware. The kinematic error correction memory for the final output includes the set of all abnormal residual parameters that pass the physical rationality judgment; This represents the total number of time steps for the omnidirectional data in the embodied perception decision log stream. During this calculation, the kinematic forward model parameters... As the core carrier of physical prior constraints, residual calculation is elevated from a simple comparison of numerical magnitudes to a judgment of physical rationality. Taking a tour guide robot performing a fixed-route tour task as an example, when the robot travels at a constant linear speed of 0.8 meters per second, the single displacement value is relatively large, but it completely conforms to the prediction results of the linear kinematics forward model. The calculated kinematic residual vector has an extremely small L2 norm, which is far below the threshold. The system filters out and discards redundant data that is deemed physically reasonable. When the robot continuously produces a lateral offset of 0.008 meters in a fixed direction during a turn, although the value of a single residual is small, this offset violates the theoretical trajectory predicted by the turning kinematics equations, and the residual vector continuously exceeds the threshold in a specific directional component. The system identifies this as a systematic hardware deviation and retains it intact in the kinematic error correction memory. Through this mechanism, the 30-day cerebellar log storage was reduced from 2.4 million entries to 36,000 entries, achieving a compression rate of 98.5%, while no effective error correction information was lost.

[0016] Next, the system uses alternative skills from the skill library to perform failure probability calibration and low-confidence path pruning on the positive causal chain of task decision call records in the embodied perception decision log stream to obtain a causal chain confidence memory set. The specific implementation process is as follows: the system filters and extracts all task decision records marked as successful from the task decision call records in the embodied perception decision log stream. For each successful record, it parses the internal skill call sequence to reconstruct the complete positive causal chain from the task requirement q triggered by the ordered skill node sequence to the successful execution result. This positive causal chain is formally represented as starting from the task requirement and sequentially calling skill nodes. , ,…, The directed causal path that ultimately leads to the successful result r. For each skill node in the positive causal chain... The system iterates through a pre-built skill library to retrieve all skills related to... Non-identical alternative skills with the same functional category but different specific implementations For each candidate alternative skill, construct a counterfactual execution path, which is the skill node in the forward causal chain. Replace with candidate alternative skills While keeping the other skill nodes unchanged, a counterfactual causal chain is formed. Based on the environmental context conditions at the time of task execution, including dynamic scene parameters such as obstacle distribution, crowd density, and equipment load, the system assesses the task failure probability of each counterfactual causal chain. This assessment process uses a large language model combined with historical execution statistics for inference and calculation. The system iterates through the failure probability assessment results of all candidate alternative skills and selects the maximum value as the current positive skill node. The confidence level is counterfactually calibrated. The semantics of this confidence level are: when all possible alternatives have an extremely high probability of failure, it indicates positive skill. In the current decision-making path and environmental context, it is the irreplaceable optimal choice, and its success is inevitable rather than accidental, thus it is given a very high confidence value; conversely, if there is an alternative skill with an extremely low probability of failure, it indicates that the positive skill... It is not the only valid choice; its success may be due to merely a coincidental match of environmental conditions rather than the superiority of the decision-making logic, thus its confidence level is suppressed. The system considers all skill nodes in the positive causal chain. to The confidence levels are multiplied one by one to obtain the total confidence level of the entire causal chain. The design logic of the multiplication operation is that the overall reliability of the entire causal chain, as a decision path executed in series, is determined by the weakest link among all skill nodes. The low confidence level of any skill node will significantly lower the overall confidence score of the chain through the multiplicative effect. The system compares the total confidence level of the entire causal chain with a preset causal chain pruning threshold: when the total confidence level is lower than the threshold, the causal chain is determined to be a path of accidental success, and its decision logic lacks reusability. The system automatically performs pruning operations to remove it from the candidate memory; when the total confidence level is greater than or equal to the threshold, the causal chain is determined to be a high-deterministic decision path, and it is encapsulated and stored in the causal chain confidence memory set along with its corresponding confidence level value. The core calculation of the above-mentioned counterfactual causal chain distillation process in the brain layer is represented as follows: in, For the i-th skill node in the positive causal chain The confidence level after counterfactual calibration ranges from [0,1]. It is the complete set of all available skills in the skill library; For retrieving from the skill library to replace positive skills The candidate alternative skills, and and Not the same name; In the current environmental context conditions Use of alternative skills Replace positive skills The estimated probability that this will lead to task execution failure; The total confidence level is the product of the confidence levels of each skill node in the entire positive causal chain. This represents the total number of skill nodes contained in this positive causal chain; This serves as the memory set for the final output causal chain confidence score. Let m be the m-th positive causal chain that has been filtered through pruning; M represents the preset causal chain pruning threshold; M is the total number of positive causal chains extracted from the task decision call record data. Taking the task of guiding tourists to the target point by the tour guide robot as an example, the positive causal chain is a series sequence of three skill nodes: path planning, obstacle avoidance navigation, and voice guidance. The system generates counterfactual alternatives such as fixed route navigation and waiting in place for the obstacle avoidance navigation skill node. After evaluation and calculation, the failure probability of all alternatives in the context of dynamic obstacles reaches a maximum of 0.95. Therefore, the confidence level of the obstacle avoidance navigation skill node is 0.95, indicating that it has extremely strong irreplaceability in the current scenario. Another guide robot successfully executed a causal chain of path planning, fixed route navigation, and voice guidance under a chance condition of temporary obstacle-free operation. After the system performed counterfactual calibration on the fixed route navigation skill nodes, it found that the failure probability of the obstacle avoidance navigation alternative was only 0.05, with extremely low positive skill confidence. The total confidence of the entire causal chain was only 0.04 after cumulative calculation, which was lower than the pruning threshold. This accidental successful path was automatically eliminated, preventing the erroneous solidification of accidental experience.

[0017] Then, based on the subsequence overlap threshold, the system performs structural similarity clustering and common subsequence extraction on the continuous skill subsequences of each causal chain in the causal chain confidence memory set to obtain the causal structure constraint template. The specific implementation process is as follows: The system traverses each causal chain in the causal chain confidence memory set. For a causal chain containing k skill nodes, the system uses a sliding window method to extract all continuous skill subsequences with a length greater than or equal to 2 and not exceeding k. All extracted continuous skill subsequences constitute the subsequence set of that causal chain. The system calculates the causal structure similarity based on the Jaccard coefficient for the subsequence sets of any two causal chains in the causal chain confidence memory set. This similarity value is obtained by dividing the intersection cardinality of the two subsequence sets by the union cardinality, and the value ranges from [0,1]. The closer the value is to 1, the higher the degree of overlap between the two causal chains at the skill call temporal structure level. The system compares the calculated causal structure similarity with a preset subsequence overlap threshold. If the similarity exceeds the threshold, the two causal chains are considered to have substantial skill call path overlap at the core execution logic level and are grouped into the same task cluster. If the similarity does not exceed the threshold, the two causal chains are considered to have essential differences in their internal causal execution structures, even if they appear similar in task type, and are not merged. After completing pairwise comparisons and clustering of all causal chains, the system performs a common continuous skill subsequence extraction operation on all causal chains within each task cluster. This involves calculating the intersection of all causal chain subsequence sets within the cluster to obtain the core skill call sequence fragment shared by all member causal chains in that task cluster. The system standardizes and encapsulates the extracted common continuous skill subsequences to generate corresponding causal structure constraint templates. These templates represent the general skill call logic constraints that must be followed during the execution of similar tasks. The core calculation of the above-mentioned central-level causal structure similarity clustering distillation process is represented as follows: In the formula, For from the first The set of all consecutive skill subsequences with a length greater than or equal to 2 extracted from the causal chain; For the first The first causal chain Skill nodes for each position; The length of the continuous skill subsequence; For the first The total number of skill nodes in the causal chain; For the first The first causal chain and the second The causal structural similarity value between causal chains; This is the set intersection operator, used to extract common skill subsequences from two sets of subsequences; This is the set union operator, used to combine all skill subsequences from two subsequence sets; The radix operator is used to calculate the total number of independent elements in a set. For the first A cluster of tasks, containing all causal chains whose similarity to the reference causal chain structure exceeds a threshold; This serves as a reference causal chain in the clustering process; The preset subsequence overlap threshold; For the first The causal structure constraint template corresponding to each task cluster consists of a set of common skill subsequences of all causal chains within the cluster. In this calculation process, the design logic of using the Jaccard intersection-union ratio of continuous skill subsequences instead of the traditional Euclidean distance of feature vectors as the clustering criterion is as follows: continuous skill subsequences directly represent the temporal logical structure and execution dependencies of skill calls within the causal chain. Only when two causal chains have substantial overlap in their core execution logic paths are they determined to be of the same type of task, thus avoiding the incorrect merging of heterogeneous tasks with similar surface features but drastically different internal causal execution structures. Taking the 487 valid causal chains generated by six intelligent agents over 30 days as an example, the overlap between the core skill subsequences of the tour guide causal chain (path planning, obstacle avoidance navigation, voice guidance) and the security causal chain (path planning, obstacle avoidance navigation, anomaly detection, alarm push) is 0.4, exceeding the preset subsequence overlap threshold of 0.3. Therefore, the system categorizes them into the same mobile inspection task cluster and extracts the common skill subsequence of path planning and obstacle avoidance navigation as a causal structure constraint template. However, while the voice guidance task causal chain (voice recognition, intent understanding, fixed route navigation) superficially belongs to the tour guide category, its core mobile skill subsequence overlap with the regular tour guide causal chain is 0, failing to meet the threshold condition. Therefore, the system separately categorizes it and generates a voice interaction causal structure constraint template. This mechanism ensures that the extracted causal structure constraint templates possess genuine causal business semantics and cross-role universality, allowing them to be directly used for skill invocation calibration and decision constraint injection in subsequent new tasks.

[0018] Specifically, in step two, the agent's memory maturity is obtained by aggregating and measuring the confidence levels of each causal chain in the causal chain confidence memory set after counterfactual calibration, using an endogenous method without manually preset weights. It should be understood that multi-agent collaborative scheduling systems require precise quantitative evaluation of each agent's actual decision-making capabilities to achieve differentiated task allocation and adaptive control of distillation depth. However, existing technologies generally use manually preset weights to linearly weight task accuracy and execution frequency to calculate maturity indicators. The weight parameters in this method lack theoretical support and are highly subjective, only reflecting the frequency of task completion and failing to characterize the quality and certainty of decision logic. This results in agents that only complete a large number of simple tasks and agents that have accumulated a small amount of high-quality complex decision-making experience receiving similar maturity scores, leading to severely insufficient accuracy in capability stratification. Therefore, in the technical solution of this application, the agent's memory maturity is further obtained by aggregating and measuring the confidence levels of each causal chain in the causal chain confidence memory set after counterfactual calibration, using an endogenous method without pre-set weights. This completely eliminates human parameter intervention, allowing the maturity index to be generated endogenously driven by the causal chain confidence levels produced by distillation, accurately characterizing the agent's irreplaceable and reliable decision-making process. This enables a causal semantic-level quantitative assessment of the agent's true decision-making ability, making the maturity index no longer a simple frequency statistic of task executions, but an endogenous measure of the quality of decision logic. This provides a capability stratification basis with strict causal semantic support for subsequent adaptive distillation depth control and gradient-based collaborative scheduling.

[0019] More specifically, in the embodiments of this application, step two includes: step 2.1, by setting a pre-set confidence threshold, performing validity filtering and quantity statistics on the confidence of each causal chain in the causal chain confidence memory set to obtain a high-confidence causal chain confidence set and a number of valid causal memories; step 2.2, based on the number of valid causal memories, performing endogenous decision determinism accumulation calculation on each confidence in the high-confidence causal chain confidence set to obtain a cumulative decision determinism value; step 2.3, performing maturity mapping on the cumulative decision determinism value to obtain the agent's memory maturity.

[0020] Specifically, in one example of this application, the system performs endogenous computation of memory maturity on the causal chain confidence memory sets accumulated by six embodied intelligent agents after sixty days of continuous operation. First, by setting a pre-defined confidence threshold, the system performs validity filtering and quantity statistics on the confidence of each causal chain in the causal chain confidence memory set to obtain a set of high-confidence causal chain confidence and the number of valid causal memories. The specific implementation process is as follows: the system loads a preset confidence validity threshold, which is used to distinguish between high-confidence causal chains with reliable decision-making reference value and marginal causal chains that are still in an uncertain state. The system iterates through each causal chain confidence memory set, collecting the total counterfactually calibrated confidence value associated with each causal chain. It compares this confidence value with a preset confidence validity threshold. If the confidence value is greater than or equal to the threshold, the causal chain is deemed to have sufficient decision certainty and reusability, and its confidence value is extracted and stored in the high-confidence causal chain confidence set. If the confidence value is lower than the threshold, the causal chain's decision logic is deemed to have significant uncertainty and is not qualified as valid input for maturity calculation, thus being excluded. After completing the full traversal, the system counts the total number of elements contained in the high-confidence causal chain confidence set and records this number as the number of valid causal memories. Taking the tour guide robot A as an example, its causal chain confidence memory set contains 23 causal chains. After validity filtering, 15 high-confidence causal chains and 5 medium-confidence causal chains are retained, totaling 20, and the number of valid causal memories is 20. However, the causal chain confidence memory set of the tour guide robot B only contains 5 causal chains, most of which are accidental success paths. After filtering, the number of valid causal memories is only 2.

[0021] Next, based on the number of effective causal memories, an endogenous cumulative calculation of decision certainty is performed on each confidence level in the high-confidence causal chain confidence set to obtain the cumulative decision certainty value. The specific implementation process is as follows: the system iterates through each confidence element in the high-confidence causal chain confidence set, multiplies the confidence level of each causal chain after counterfactual reasoning calibration with a logarithmic growth factor endogenously generated based on the number of effective causal memories, and then sums all the product results to obtain the cumulative decision certainty value. The logarithmic growth factor is calculated by adding 1 to the number of effective causal memories and then taking the common logarithm. This factor is entirely endogenously determined by the number of effective memories produced by distillation without any manually preset weights. The design logic of the logarithmic growth factor is as follows: when the agent accumulates only a small amount of effective memory, the logarithmic growth factor is small. Even if the confidence of a single causal chain is high, the cumulative result is still at a low level, reflecting the inhibitory effect of insufficient experience breadth on maturity. As the number of effective causal memories continues to increase, the logarithmic growth factor slowly increases, providing a sublinear amplification to the total accumulation. This rewards the contribution of the breadth of experience accumulation while suppressing the artificially high effect caused by simply stacking simple tasks through the asymptotic saturation characteristic of the logarithmic function. The core formula for the above-mentioned endogenous decision deterministic cumulative calculation is expressed as: In the formula, The cumulative value of decision certainty for the calculation output characterizes the overall decision certainty strength accumulated by the agent based on effective causal memory; This is the set of high-confidence causal chain confidence obtained after validity filtering, that is, the effective subset of the agent's brain-level causal memory set that has been filtered by the threshold. Let be the confidence level of the ii-th causal chain in the set of high-confidence causal chain confidence levels, after being calibrated by counterfactual reasoning. The number of valid causal memories is the total number of elements contained in the set of confidence levels for high-confidence causal chains. These are commonly used logarithmic operators; This is the logarithmic growth factor for the breadth of experience, endogenously generated based on the number of effective causal memories. In this formula, the summation part... The counterfactual calibration confidence scores of all valid causal chains are summed, with each high-confidence causal chain contributing a large positive value, reflecting the total decision reliability accumulated by the agent through continuous execution of highly deterministic decision-making tasks; multiplication factor. As an endogenous amplification factor for experience breadth, it provides a moderate capability enhancement to agents with a large amount of accumulated experience based on the accumulation of confidence levels. However, due to the asymptotic saturation characteristic of the logarithmic function, this enhancement diminishes marginally with the increase in the number of effective causal memories, preventing the accumulated value from linearly increasing due to the expansion of the number of simple tasks. Taking the tour guide robot A as an example, its twenty effective causal memories include fifteen high-confidence links, each with a relatively high confidence level. Multiplying by... The cumulative decision certainty value obtained by summing the logarithmic growth factors is significantly higher than that obtained by using only two valid memories with a logarithmic growth factor of [value missing]. The tour guide robot B.

[0022] Then, maturity mapping is applied to the cumulative decision certainty value to obtain the agent's memory maturity. The specific implementation process is as follows: the system receives the cumulative decision certainty value calculated in the previous stage, and performs mean normalization mapping on this cumulative value using the number of effective causal memories. That is, the cumulative decision certainty value is divided by the number of effective causal memories to obtain the final agent's memory maturity. The design logic of this mean normalization is that the cumulative decision certainty value itself increases with the number of effective causal memories. If this cumulative value is directly used as a maturity indicator, fair comparison of capabilities between agents with different levels of experience accumulation cannot be made. Mean normalization maps the total cumulative value back to the baseline of the average contribution level of a single memory, and then the logarithmic growth factor preserves the reward effect of experience breadth, so that the final maturity simultaneously reflects the average level of decision quality and the breadth and depth of experience accumulation. The core formula for the above maturity mapping is expressed as: In the formula, The final output is the agent's memory maturity, which is used to characterize the agent's decision-making stability and knowledge maturity at the current stage. conf(chaini) represents the set of causal memories at the brain level of the intelligent agent, i.e., the set of high-confidence causal chain confidence scores after validity filtering; conf(chaini) represents the confidence score of a single causal chain after counterfactual reasoning calibration. This represents the number of effective causal memory entries. Within the overall structure of this formula, The arithmetic mean of the confidence of effective causal chains was calculated in part. This mean directly reflects the average quality level of the decision-making experience accumulated by the agent. Agents that only complete simple tasks or rely on accidental success have a lower mean because the number of high-confidence causal chains is small. Part of the logarithmic growth reward factor, representing the breadth of experience, provides a moderate capability enhancement bonus to agents with a large amount of accumulated experience, based on the mean. However, due to the asymptotic saturation characteristic of the logarithmic function, this bonus diminishes marginally with the increase in the number of effective causal memories, reflecting the objective law of diminishing marginal returns in capability enhancement and preventing maturity from growing indefinitely due to the expansion of experience quantity. Taking the results of six agents operating for sixty days as an example, the tour guide robot A accumulated twenty effective causal memories, fifteen of which were high-confidence links, with a high mean confidence level and a logarithmic growth factor. Sufficient breadth rewards were provided, and the calculated agent's memory maturity was 0.879, placing it in the high maturity range. The guide robot B, however, only had two valid causal memories with low mean confidence levels and a low logarithmic growth factor. The difference is also relatively small; after calculation, the agent's memory maturity is only 0.282, which is in the low maturity range. The maturity differentiation between the two reaches 0.597, which is much higher than the 0.438 differentiation of the traditional manual weighted formula, verifying the significant advantage of the causal endogenous computing mechanism in the accuracy of capability stratification.

[0023] Specifically, in step three, based on the agent's memory maturity, the causal chain confidence memory set and causal structure constraint template are dynamically reconstructed into a cross-task causal transfer network graph to obtain a cross-task causal transfer graph. It should be understood that when existing agents face entirely new task types they have never performed before, the lack of a cross-task experience transfer mechanism means that their existing heterogeneous task history experience cannot be effectively reused. They can only make random exploratory decisions from scratch, severely restricting the agent's generalization ability and evolutionary potential. Furthermore, if all agents are allowed to indiscriminately publish their experiences to the global shared space, the low-quality memories carried by agents with low maturity will pollute the global knowledge base, causing noise diffusion and a decrease in transfer reliability. Therefore, in the technical solution of this application, based on the agent's memory maturity, the cross-task causal transfer network graph is dynamically reconstructed using the causal chain confidence memory set and the causal structure constraint template to obtain a cross-task causal transfer graph. This is used to establish a global experience topology network with maturity as the gating condition, allowing only high-quality causal memories from high-maturity agents to enter the global graph. Cross-task transfer channels are established through structural matching of shared skill subsequences between heterogeneous task causal chains. In this way, the controllable aggregation and structured reuse of heterogeneous task experiences from multiple agents can be achieved. The transfer knowledge accumulated in the global graph has undergone sufficient counterfactual verification, providing a highly reliable cross-task experience topology foundation for the generation of prior constraints for subsequent new tasks. Moreover, the graph expands incrementally as the system continues to run, continuously enhancing the transfer capability and achieving emergent capability evolution.

[0024] Figure 3 This is a flowchart of step three of the multi-embodied intelligent agent hierarchical memory collaborative self-evolution method according to an embodiment of this application. Figure 3 As shown, step three includes: Step 3.1, based on a preset high-order transfer threshold, gating qualification is performed on the agent's memory maturity to screen the causal chain confidence memory set and causal structure constraint template, resulting in a gated authorization causal memory set and a gated authorization constraint template; Step 3.2, through matching and retrieval of shared continuous skill subsequences between heterogeneous causal chains, cross-task association edge construction and geometric average weight assignment are performed on the gated authorization causal memory set and the gated authorization constraint template to obtain candidate transfer nodes and weight edge sets; Step 3.3, incremental topological fusion and repeated edge weight smoothing correction are performed on the candidate transfer nodes and weight edge sets and the existing global graph to obtain a cross-task causal transfer graph.

[0025] Specifically, in one example of this application, the system performs cross-task dynamic reconstruction of the causal transfer network graph at the central control platform level, based on the causal chain confidence memory sets and causal structure constraint templates accumulated by six embodied agents after sixty days of operation. First, based on a preset high-order transfer threshold, the system performs gating qualification assessment on the agent's memory maturity to filter the causal chain confidence memory sets and causal structure constraint templates, resulting in gated authorized causal memory sets and gated authorized constraint templates. The specific implementation process is as follows: the system loads the preset high-order transfer threshold, which is used to determine whether the agent is qualified to publish high-order transfer knowledge to the global graph. The system reads the memory maturity of each agent calculated in the previous step and compares it with a preset higher-order transfer threshold. When the agent's memory maturity is greater than or equal to the higher-order transfer threshold, the system determines that the agent has accumulated a sufficient amount of high-deterministic decision-making experience and is qualified to share global knowledge. The system reads the agent's corresponding causal chain confidence memory set and causal structure constraint template, adds a gating authorization identifier, and outputs a gating authorization causal memory set and a gating authorization constraint template. When the agent's memory maturity is lower than the higher-order transfer threshold, the system determines that the agent's decision-making experience has not been sufficiently accumulated and verified, and is not qualified to contribute transfer knowledge to the global graph. The system intercepts the agent's upload request and retains the corresponding causal chain confidence memory set in local storage space for its own subsequent distillation use only. Taking the results of six intelligent agents running for sixty days as an example, the preset high-order transfer threshold is set to 0.8. The agent memory maturity of the tour guide robot A is 0.879, which exceeds this threshold. The system authorizes its causal chain confidence memory set and causal structure constraint template to enter the global graph construction process, and the output is a gated authorized causal memory set and a gated authorized constraint template. The agent memory maturity of the tour guide robot B is 0.282, the agent memory maturity of the security robot D is 0.691, and the agent memory maturity of the explanation robot E is 0.433, all of which are lower than the high-order transfer threshold. The system blocks their upload requests to prevent low-quality memory from polluting the global graph.

[0026] Next, by matching and retrieving shared continuous skill subsequences between heterogeneous causal chains, cross-task association edges are constructed and geometric average weights are assigned to the gated authorization causal memory set and gated authorization constraint template to obtain candidate migration nodes and weighted edge sets. The specific implementation process is as follows: The system receives the gated authorization causal memory set and gated authorization constraint template that have passed the gated screening, and extracts the skill nodes of all causal chains as candidate migration nodes. The system performs pairwise pairwise traversal of heterogeneous causal chains from different task types in the gated authorization causal memory set, extracts its continuous skill subsequence set for each pair of heterogeneous causal chains, and searches whether there are shared continuous skill subsequence fragments between them. When there is at least one shared continuous skill subsequence between two heterogeneous causal chains, the system establishes a cross-task association migration edge between the skill nodes involved in the shared subsequence. This migration edge represents a feasible channel for knowledge transfer from one type of task experience to another type of task experience. The system calculates the weight value for each newly established cross-task related migration edge. This weight value is obtained by extracting the counterfactually calibrated confidence scores of the two source causal chains and calculating their geometric mean. The selection logic for the geometric mean is that it is more sensitive to the smaller of the two input values, ensuring that the migration edge weight is limited to the less reliable one of the two source causal chains, avoiding the risk of the uncertainty of the other chain being masked by a unilateral increase in weight from a high-confidence chain. The system collects and encapsulates all newly established candidate migration nodes and their associated weighted migration edges, outputting a set of candidate migration nodes and weighted edges. The core formula for assigning the weights of the aforementioned cross-task related migration edges is expressed as follows: In the formula, For skill nodes With skill nodes The weight values ​​of the cross-task associated migration edges established between them belong to the candidate migration node and the set of weighted edges; To connect skill nodes With skill nodes migration edges; For including skill nodes The confidence level of a single causal chain after counterfactual reasoning calibration of the source causal chain is extracted from the gated authorized causal memory set; For including skill nodes The confidence level of a single causal chain after counterfactual reasoning calibration of the source causal chain is extracted from the gated authorized causal memory set; The square root operator, along with multiplication, forms the geometric mean calculation. In this formula, the product part... The confidence levels of the two source causal chains are coupled to ensure that the product value is large only when both ends of the causal chain have high confidence. The square root part maps the product result back to the same numerical magnitude as the single confidence level, so that the physical meaning of the migration edge weight is consistent with the semantic interpretation space of the causal chain confidence. Taking the gated authorization causal memory set of the tour guide robot A as an example, the overall confidence level of the tour guide causal chain path planning, obstacle avoidance navigation, and voice guidance is 0.91, and the overall confidence level of the security causal chain path planning, obstacle avoidance navigation, anomaly detection, and alarm push is 0.87. The two share continuous skill subsequence path planning and obstacle avoidance navigation. The system establishes cross-task related migration edges between the skill nodes of this shared subsequence and calculates the weight as 0.91 × 0.87 = 0.89, indicating that the migration channel has high historical verification reliability.

[0027] Then, the system performs incremental topological fusion and smoothing correction of repeated edge weights on the candidate migration nodes and weighted edge sets with the existing global graph to obtain a cross-task causal migration graph. The specific implementation process is as follows: The system retrieves the existing global graph currently maintained by the central control platform. This graph is stored in the form of a directed weighted topological network, where the vertex set contains all historically accumulated standardized skill nodes, and the edge set contains all historically accumulated weighted migration edges. The system matches the names of newly added skill nodes in the candidate migration nodes and weighted edge sets one by one with the vertex set of the existing global graph: for new skill nodes that do not yet exist in the existing global graph, the system directly inserts them into the vertex set to complete node expansion; for existing skill nodes with the same name, the system keeps the original node unchanged and establishes a reference association. The system matches each candidate migration node and newly added weighted migration edge in the weighted edge set with the edge set of the global graph, performing start-end node pair matching. For new migration edges not yet present in the global graph, the system directly inserts them along with their weight values ​​into the edge set to expand the edge. For existing duplicate migration edges (edges with the same start-end node pair), the system uses an exponential moving average algorithm to smoothly fuse and correct the old and new weights. The historical accumulated weights and the newly calculated weights in this round are weighted and mixed according to a preset smoothing coefficient to obtain updated edge weight values, avoiding drastic disturbances to the global graph topology caused by accidental fluctuations in single task experience. After completing the incremental fusion operation of all nodes and edges, the system performs connectivity verification and isolated node cleanup on the updated global graph to ensure that each skill node in the graph is associated with at least one migration edge. The final output is a cross-task causal migration graph. Taking the global graph state at the end of the 60-day operation as an example, after multiple rounds of incremental fusion, the cross-task causal transfer graph contains eleven standardized skill nodes and nine weighted transfer edges, covering cross-task experience transfer channels between three types of tasks: tour guiding, security, and interpretation. Furthermore, as highly mature agents continue to contribute new, high-quality causal chains, the graph expands to twenty-seven nodes and thirty-one transfer edges by the 120-day mark, continuously enhancing its transfer capability. This cross-task causal transfer graph will serve as the retrieval space for generating new task prior constraint templates in subsequent steps, providing reusable and highly reliable historical experience topology support for embodied agents facing entirely new tasks.

[0028] Specifically, in step four, a gradient-based task allocation is performed on multiple agents based on their memory maturity, and maximum overlap subgraph matching is performed on the new task skill sequence in the cross-task causal transfer graph to obtain differentiated scheduling instructions and cross-task prior constraint templates. It should be understood that, due to significant differences in actual decision-making capabilities among agents with the same role in a multi-agent collaborative scheduling system, if task matching and assignment are based solely on role type while ignoring individual capability differences, inexperienced, low-maturity agents will be assigned high-complexity tasks beyond their capabilities, leading to frequent execution failures. Simultaneously, high-maturity agents will undertake low-complexity tasks, resulting in a waste of their superior decision-making capabilities. This leads to a high overall task failure rate and severe misallocation of computational resources. Furthermore, when facing entirely new tasks, if agents cannot effectively retrieve and reuse existing highly reliable historical experience from the cross-task causal transfer graph, they will have to start from scratch with exploratory decision-making, resulting in an extremely low first-time success rate. Therefore, in the technical solution of this application, a gradient task allocation is further performed on multiple agents based on the agent's memory maturity, and maximum overlap subgraph matching is performed on the new task skill sequence in the cross-task causal transfer graph to obtain differentiated scheduling instructions and cross-task prior constraint templates. This achieves fine-grained scheduling based on real capabilities and injection of prior constraints based on reliable historical experience. In this way, it can be ensured that each agent undertakes a task complexity level that matches its own decision-making ability. High-maturity agents prioritize handling high-complexity tasks to ensure the execution quality of critical tasks, while low-maturity agents undertake basic tasks to achieve gradient growth. At the same time, the decision-making process of new tasks can obtain highly reliable causal logic constraints extracted from historical heterogeneous tasks as prior guidance, which greatly improves the first execution accuracy of new tasks.

[0029] Figure 4 This is a flowchart of step four of the multi-embodied intelligent agent hierarchical memory collaborative self-evolution method according to an embodiment of this application. Figure 4 As shown, step four includes: Step 4.1, based on the high, medium and low gradient levels of agent memory maturity, priority matching and assignment and weighted allocation of computing power and bandwidth are performed on multiple agents and subtasks of different complexities to obtain differentiated scheduling instructions; Step 4.2, using the standardized candidate skill subsequences obtained by decomposing the new task skill sequence as retrieval conditions, global subgraph traversal and intersection-union ratio (IUU) overlap quantification are performed on the cross-task causal migration graph to obtain the subgraph with the maximum overlap; Step 4.3, the validity of the subgraph with the maximum overlap is determined based on the preset overlap activation threshold, wherein the high-confidence causal chains in the subgraph exceeding the threshold are subjected to prior logic constraint extraction and template encapsulation to obtain cross-task prior constraint templates.

[0030] Accordingly, in step 4.1, based on the high, medium, and low gradient classification results of agent memory maturity, priority matching and assignment, as well as weighted allocation of computing power and bandwidth, are performed on multiple agents and subtasks of different complexities to obtain differentiated scheduling instructions. It should be understood that, due to the significant differentiation in actual decision-making capabilities among different agents with the same role in a multi-agent collaborative scheduling system due to differences in task experience accumulation, if task matching and assignment are uniformly performed based solely on role type while ignoring individual capability differences, inexperienced, low-maturity agents will be assigned high-complexity tasks beyond their capabilities, leading to frequent execution failures. Simultaneously, high-maturity agents will undertake low-complexity tasks, resulting in the idle waste of their superior decision-making capabilities. The overall collaborative task completion rate will be low, and scarce resources such as shared computing power and knowledge base retrieval bandwidth will be evenly distributed instead of being allocated to critical tasks, resulting in severely inefficient resource utilization. Therefore, in the technical solution of this application, based on the high, medium, and low gradient levels of agent memory maturity, priority matching and assignment, as well as weighted allocation of computing power and bandwidth, are performed on multiple agents and sub-tasks of different complexities to obtain differentiated scheduling instructions. This achieves refined task assignment and resource allocation based on actual decision-making capabilities, ensuring that each agent undertakes task complexity commensurate with its own maturity level. This allows high-maturity agents to prioritize high-complexity critical tasks and obtain sufficient computing power and bandwidth resources, while low-maturity agents undertake basic tasks to achieve stable gradient growth. The overall collaborative task completion rate and resource utilization efficiency are improved simultaneously. Furthermore, the differentiated task allocation mechanism can generate new log data of different quality and dimensions for each agent, providing diverse data inputs for subsequent closed-loop iterative distillation.

[0031] In a specific example of this application, firstly, the agent's memory maturity calculated in step two is read, and a preset gradient classification threshold system is loaded for hierarchical division. The system sets a high-order migration threshold and a basic distillation threshold as two dividing points, and divides the six agents into three gradient levels according to their agent memory maturity values: agents with a memory maturity greater than or equal to the high-order migration threshold are assigned to the high-maturity gradient queue; agents with a memory maturity greater than or equal to the basic distillation threshold but lower than the high-order migration threshold are assigned to the medium-maturity gradient queue; and agents with a memory maturity lower than the basic distillation threshold are assigned to the low-maturity gradient queue. Taking the results of six intelligent agents running for sixty days as an example, the high-order transfer threshold was set to 0.8 and the basic distillation threshold was set to 0.4. The agent memory maturity of the tour guide robot A was 0.879, and it was classified into the high maturity gradient queue; the agent memory maturity of the security robot D was 0.691, the agent memory maturity of the guide robot C was 0.512, and the agent memory maturity of the explanation robot E was 0.433, and they were all classified into the medium maturity gradient queue; the agent memory maturity of the tour guide robot B was 0.282, and it was classified into the low maturity gradient queue.

[0032] Next, the system performs complexity analysis and subtask decomposition on the large-scale event support coordination tasks to be executed. The system comprehensively evaluates each subtask based on dimensions such as skill call chain length, environmental dynamism, real-time decision-making requirements, and the severity of consequences of task failure, decomposing the complete coordination task into a set of subtasks with different complexity levels. In the large-scale event support scenario, the system classifies the VIP main passage guidance task as a high-complexity subtask, requiring dynamic obstacle avoidance and personalized path planning in high-density crowds, with strong environmental dynamism and severe consequences of task failure; the side path guidance task and exhibit explanation task are classified as medium-complexity subtasks, where the execution environment is relatively controllable but still requires a certain level of real-time decision-making ability; and the perimeter patrol task is classified as a low-complexity subtask, where the path is fixed and the environment changes little.

[0033] Then, the priority matching and assignment logic is executed to match subtasks of different complexity levels with agents of corresponding gradient levels. The system prioritizes assigning the high-complexity VIP main passage guidance task to guide robot A in the high-maturity gradient queue. This agent has accumulated sufficient high-deterministic decision-making experience and can effectively cope with complex decision-making scenarios in highly dynamic environments. The medium-complexity branch path guidance task is assigned to guide robot B in the low-maturity gradient queue. This task has moderate complexity, which will not lead to execution failure due to exceeding its capabilities, and can provide low-maturity agents with effective experience accumulation opportunities to achieve gradient growth. The medium-complexity exhibit explanation task is assigned to explanation robot E in the medium-maturity gradient queue. The low-complexity perimeter patrol task is assigned to security robot D in the medium-maturity gradient queue, reserving redundancy for handling sudden abnormal events.

[0034] Finally, while completing task assignment, the system weights and allocates public knowledge base retrieval bandwidth and computing resources according to the agent's memory maturity. Based on the total available retrieval bandwidth, the system allocates bandwidth quotas according to the proportion of each agent's memory maturity to the total maturity of all scheduled agents. This ensures that high-maturity agents receive a larger knowledge base retrieval bandwidth to guarantee their ability to quickly retrieve causal memories for decision-making when performing complex tasks, while low-maturity agents receive a basic bandwidth quota to meet the needs of simple tasks. For example, with a total retrieval bandwidth of 100 QPS, after the system weights the allocation by maturity, tour guide robot A receives approximately 32 QPS, security robot D receives approximately 25 QPS, guidance robot C receives approximately 19 QPS, explanation robot E receives approximately 16 QPS, and tour guide robot B receives approximately 8 QPS. The high-maturity agents prioritize resource allocation, reducing their decision-making latency by 23%. The system encapsulates the task assignment results, execution priorities, resource quotas, and task timeout constraints of each agent in a structured manner and outputs them as differentiated scheduling instructions. These differentiated scheduling instructions will be sent to the execution layer of each agent together with cross-task prior constraint templates in subsequent steps to drive the coordinated execution of physical tasks.

[0035] Accordingly, in step 4.2, the standardized candidate skill subsequences obtained from the decomposition of the new task skill sequence are used as retrieval conditions to perform global subgraph traversal and cross-union ratio (CUNR) overlap quantification on the cross-task causal transfer graph to obtain the subgraph with the maximum overlap. It should be understood that when facing a completely new task type, the embodied agent needs to quickly retrieve the historical experience subgraph that best matches the skill requirements of the new task from the cross-task causal transfer graph in order to reuse the highly reliable causal logic accumulated therein as decision priors. However, the cross-task causal transfer graph, as a global topological network, contains nodes and transfer edges composed of a large number of heterogeneous task experiences. If the graph is not systematically traversed and its matching degree is not quantified, the system will not be able to determine which part of the historical experience has the highest coverage of the skill requirements of the new task, and thus will be unable to generate targeted prior constraint templates. The agent will still be trapped in the dilemma of exploratory decision-making from scratch. Therefore, in the technical solution of this application, the standardized candidate skill subsequences obtained by decomposing the new task skill sequence are used as retrieval conditions. A global subgraph traversal and intersection-union-ratio (IUU) overlap quantification are performed on the cross-task causal transfer graph to obtain the subgraph with the maximum overlap. This allows for the precise location of the historical experience subset that best covers the new task skill requirements within the global experience topology space. This ensures that the generation of subsequent prior constraint templates is based on historical experience that highly matches the new task skill structure, maximizing the prior guidance value of historical heterogeneous task experience for new task decision-making. This enables the agent to make high-starting-point decisions based on the optimal historical experience subgraph rather than starting from zero random decision-making when facing a new task.

[0036] In a specific example of this application, the system receives a new VIP customized guided tour task during a large-scale event in a commercial complex. It needs to retrieve the optimal historical experience subgraph for this new task from a cross-task causal migration graph containing eleven standardized skill nodes and nine weighted migration edges. First, the system receives the skill requirement description for the new VIP customized guided tour task, and the brain-level decision-making module decomposes the new task into a standardized skill sequence. Based on the execution goals and process constraints of the new task, the system decomposes the complete task into an ordered sequence of standardized skill nodes. Each skill node in this sequence corresponds to an independent skill that must be invoked during the execution of the new task. The system aggregates all the decomposed skill nodes to form a standardized candidate skill subsequence set, which serves as the query condition for subsequent graph retrieval. Taking the VIP customized guided tour task as an example, the system decomposes it into four standardized skill nodes: path planning, obstacle avoidance navigation, voice guidance, and personalized recommendation, forming a standardized candidate skill subsequence set.

[0037] Next, using the standardized candidate skill subsequence set as the retrieval condition, a global subgraph traversal enumeration is performed on the cross-task causal transfer graph. Within the complete topological network of the cross-task causal transfer graph, the system employs a depth-first search or breadth-first search strategy to enumerate all candidate subgraphs that satisfy connectivity constraints. Connectivity constraints require that there be at least one path connecting skill nodes within each enumerated candidate subgraph via a transfer edge, ensuring that the historical experience carried by the candidate subgraph has a complete skill switching logical chain rather than isolated knowledge fragments. During the enumeration process, the system sets an upper bound constraint on the size of the candidate subgraphs, filtering out redundant subgraphs that are too large and contain a large number of irrelevant skill nodes, thus reducing subsequent computational overhead.

[0038] Then, for each enumerated candidate subgraph, the Jaccard intersection-union ratio (JUCR) overlap ratio between it and the standardized candidate skill subsequence set is calculated. The system extracts the set of skill nodes contained in the candidate subgraph, calculates the intersection cardinality and union cardinality of this skill node set and the standardized candidate skill subsequence set, and divides the intersection cardinality by the union cardinality to obtain a quantitative measure of the node coverage matching degree between the candidate subgraph and the new task. The core formula for the maximum overlap subgraph retrieval described above is expressed as follows: In the formula, The result is the subgraph with the highest overlap in the retrieval output; A complete topological network of cross-task causal migration graphs; For any connected candidate subgraph enumerated from the cross-task causal migration graph; Candidate subgraph The set of skill nodes it contains; It is a set of standardized candidate skill subsequences obtained by decomposing the new task skill sequence; This is the intersection operator for sets; This is the set union operator; The radix operator is used to calculate the total number of independent elements in a set. In this formula, the numerator part... Candidate subgraphs were statistically analyzed. The percentage of skill nodes in the candidate subgraph that overlap with the skills required for the new task indicates how well the candidate subgraph covers the skill requirements of the new task, and how much directly reusable historical decision-making experience it can provide. The denominator... The total non-repeating size of the candidate subgraph skill nodes and the new task skill nodes is statistically analyzed to normalize the data and prevent large candidate subgraphs from obtaining unreasonable high matching scores simply because they contain a large number of redundant skill nodes that are unrelated to the new task. The ratio obtained by dividing the two is the Jaccard intersection-union ratio overlap, which ranges from zero to one. The closer the value is to one, the higher the degree of overlap of skill nodes between the candidate subgraph and the new task and the fewer redundant nodes there are.

[0039] After calculating the overlap ratio (CR) of all candidate subgraphs, the candidate subgraph with the highest overlap ratio is selected as the final output subgraph with the highest overlap. Taking the VIP customized tour guide task as an example, the standardized candidate skill subsequence set contains four skill nodes: path planning, obstacle avoidance navigation, voice guidance, and personalized recommendation. After the system performs a global traversal of the cross-task causal migration graph containing eleven nodes and nine migration edges, it enumerates multiple candidate subgraphs that satisfy connectivity constraints. One candidate subgraph contains three skill nodes: path planning, obstacle avoidance navigation, and voice guidance. Its intersection cardinality with the standardized candidate skill subsequence set is three, its union cardinality is four, and its Jaccard CR overlap ratio is 0.75. Another candidate subgraph contains two skill nodes: path planning and anomaly detection. Its intersection cardinality is one, its union cardinality is five, and its overlap ratio is only 0.2. The system selects the candidate subgraph with an overlap of 0.75 as the output subgraph with the maximum overlap. This subgraph carries highly reliable causal experience from the path planning to obstacle avoidance navigation and then to voice guidance in the historical tasks of navigation and security. It will be used for the extraction and encapsulation of prior constraint templates in subsequent steps.

[0040] Specifically, in sub-step 4.2 of the multi-agent hierarchical memory collaborative self-evolution method, the first embodiment described above, when performing maximum overlap subgraph retrieval on the cross-task causal transfer graph, only uses the Jaccard intersection-union ratio between the candidate subgraph node set and the new task skill sequence as the sole matching criterion. The formula calculation in the first embodiment only involves set operations at the node level, i.e., counting how many skill nodes in the candidate subgraph overlap with the skills required by the new task, completely ignoring the weight attributes carried by the transfer edges connecting these skill nodes in the cross-task causal transfer graph. In the graph construction stage of step three, the weight of each transfer edge is assigned by the geometric mean of the confidence scores of the two source causal chains; its data essence is a quantitative representation of the historical verification reliability strength of the skill switching path. In other words, the transfer edge weight directly reflects the credibility of historical task experience after counterfactual calibration on this transfer channel. In the actual physical execution scenario of embodied agents, this deficiency leads to the following problem: when multiple candidate subgraphs score similarly in the node overlap dimension, the first embodiment may select a subgraph with broad skill coverage but generally low internal migration edge weights. Low migration edge weights mean that the historical experience paths connecting these skill nodes have not undergone sufficient counterfactual verification, and are subject to chance and uncertainty. If the causal constraints carried by such weakly reliable subgraphs are injected as priors into the decision-making process of new tasks, the embodied agent will follow unverified decision logic during actual motion control and skill chain switching.

[0041] Taking a commercial complex tour guide robot as an example, when a new task requires a skill chain of path planning → obstacle avoidance navigation → elevator interaction → floor switching, if the weight of the transition edge from obstacle avoidance navigation to elevator interaction in the matched subgraph is extremely low (supported only by a few accidental historical successful verifications), then when the robot performs the physical action connection from obstacle avoidance navigation to elevator interaction, it is very likely to hesitate in decision-making or make incorrect skill call timing due to unreliable prior constraints, ultimately leading to actual execution failure consequences such as physical collisions, task interruption, and increased retry cycle.

[0042] To address the aforementioned technical deficiencies, a second embodiment is proposed. Specifically, in another specific example of this application, Figure 5 This is a flowchart of step 4.2 of the multi-embodied intelligent agent hierarchical memory cooperative self-evolution method according to an embodiment of this application. Step 4.2 includes: Step 4.2.1, based on a preset overlap admission threshold, screening candidate subgraphs that overlap with nodes of the new task skill sequence in the cross-task causal migration graph and extracting the minimum weight of internal migration edges to obtain a candidate subgraph bottleneck reliability evaluation set; Step 4.2.2, based on the node intersection-union ratio overlap and the migration path bottleneck reliability, performing joint matching score optimization on the candidate subgraph bottleneck reliability evaluation set to obtain the matching subgraph with the maximum overlap.

[0043] In step 4.2.1, based on a preset overlap threshold, candidate subgraphs in the cross-task causal transfer graph that overlap with nodes of the new task skill sequence are screened and their internal transfer edges are extracted using the minimum weight method, resulting in a candidate subgraph bottleneck reliability assessment set. It is understandable that before performing a global topological traversal in the cross-task causal transfer graph, it is necessary to first screen a large number of candidate subgraphs and evaluate the reliability lower bound of their internal paths. This is because: if joint scores are calculated directly on the entire quantum graph without threshold filtering, a large number of sparse subgraphs highly unrelated to the new task skills will consume ineffective computational resources; and in the candidate subgraphs that pass the threshold screening, knowing only the node overlap is insufficient to determine the execution reliability of the transfer knowledge, and it is necessary to further quantify the weakness of the internal transfer paths of each subgraph. Therefore, in the technical solution of this application, based on a preset overlap threshold, candidate subgraphs that overlap with the skill sequence nodes of the new task in the cross-task causal migration graph are further screened and their internal migration edges are extracted with minimum weight. This yields a bottleneck reliability evaluation set for candidate subgraphs, thereby quantifying the execution safety lower bound of the internal migration path for each candidate subgraph that passes the threshold while controlling computational overhead. This provides a complete data foundation for subsequent joint optimization, incorporating both structural coverage information and path reliability lower bound information, enabling the final selected subgraph to achieve a balance between skill coverage breadth and execution safety assurance.

[0044] More specifically, in a concrete example of this application, firstly, a standardized set of candidate skill subsequences is extracted from the new task skill sequence. Using this as a retrieval criterion, a global topological traversal is performed on the cross-task causal migration graph, calculating the intersection-union ratio (IU) overlap between nodes in each connected subgraph and the standardized candidate skill subsequence set. For each connected candidate subgraph enumerated in the cross-task causal migration graph, the system extracts its skill node set and calculates the IU overlap between this skill node set and the standardized candidate skill subsequence set. The system compares the calculated overlap with a preset minimum overlap threshold: when the overlap is greater than or equal to the threshold, the candidate subgraph is deemed to have sufficient skill structure relevance to the new task and is retained for subsequent bottleneck reliability assessment; when the overlap is lower than the threshold, the candidate subgraph is deemed highly unrelated to the skill requirements of the new task and is directly excluded to avoid unnecessary computational resource consumption. Taking the VIP customized guided tour task as an example, the standardized candidate skill subsequence set includes four skill nodes: path planning, obstacle avoidance navigation, voice guidance, and personalized recommendation. The preset minimum overlap threshold is set to 0.3. In the multiple candidate subgraphs enumerated by the system in the cross-task causal transfer graph, candidate subgraph A, which contains three nodes (path planning, obstacle avoidance navigation, and voice guidance), has an overlap of 0.75, exceeding the threshold and is retained; candidate subgraph B, which contains two nodes (path planning and obstacle avoidance navigation), has an overlap of 0.4, exceeding the threshold and is retained; and candidate subgraph C, which only contains two nodes (anomaly detection and alarm push), has an overlap of 0, below the threshold and is directly excluded.

[0045] Next, for each candidate subgraph that passes the admission screening, the system traverses all its internal migration edges, extracts the migration weight values ​​of each edge, and takes the minimum value as the bottleneck reliability of the migration path for that subgraph. The core calculation of this bottleneck reliability is expressed as follows: In the formula, Candidate subgraph The reliability value of the migration path bottleneck. Candidate subgraph The set of all migration edges contained within. For subgraph Connecting skill nodes With skill nodes migration edge, The weight assigned to this migration edge during graph construction is determined by the geometric mean of the confidence scores of the two source causal chains, directly reflecting the historical reliability strength of the skill switching path after counterfactual calibration. The design logic of using a minimum value operation instead of a mean or summation operation in this formula stems from the serial nature of the chained execution of skills by embodied agents. It can be understood that the actual execution reliability of a skill migration link is determined by its weakest skill switching link, analogous to the overall resistance in a series circuit being limited by the narrowest conductor. Regardless of the weights of the other migration edges in the subgraph, as long as there is a weak edge with an extremely low weight, the decision-making link may break at that weak link during physical execution. Taking a navigation robot for a commercial complex as an example, when candidate subgraph A contains two migration edges: path planning to obstacle avoidance navigation and obstacle avoidance navigation to voice guidance, if the weight of the migration edge from path planning to obstacle avoidance navigation is 0.89 and the weight of the migration edge from obstacle avoidance navigation to voice guidance is 0.92, then the reliability of the migration path bottleneck in this subgraph is the minimum of the two, 0.89, indicating that the weakest link in this subgraph still maintains a high level of reliability. If another candidate subgraph B has a migration edge weight of 0.85 from path planning to obstacle avoidance navigation and a migration edge weight of 0.92 from obstacle avoidance navigation to elevator interaction, then the reliability of the migration path bottleneck in this subgraph is the minimum of the two, 0.89, indicating that the weakest link in this subgraph still maintains a high level of reliability. With a weight of only 0.12, even if the weight of the previous edge is high, the reliability of the migration path bottleneck in this subgraph is still reduced to 0.12. This indicates that there is an extremely weak migration path in this subgraph supported only by a few accidental successful historical verifications. If the causal constraints carried by such subgraphs are injected as priors into the decision-making process of new tasks, when the embodied agent performs the physical action connection between obstacle avoidance navigation and elevator interaction, it is very likely to hesitate in decision-making or make incorrect skill call timing due to the unreliability of prior constraints. This will eventually lead to actual execution failures such as physical collisions, task interruptions, or increased retry cycles.

[0046] Then, each candidate subgraph and its corresponding migration path bottleneck reliability value are associated and encapsulated, outputting a candidate subgraph bottleneck reliability evaluation set. Each element in this set contains three complete data items: the topological structure information of the candidate subgraph itself, its intersection-union ratio with the new task's nodes, and the bottleneck reliability value of its internal migration path. This provides a complete data foundation with both structural coverage information and path reliability lower limit information for subsequent joint matching score optimization, enabling the finally selected subgraph to achieve a balance between skill coverage breadth and execution safety assurance.

[0047] In step 4.2.2, based on the node intersection-union ratio overlap and the migration path bottleneck reliability, a joint matching score is performed on the candidate subgraph bottleneck reliability evaluation set to obtain the subgraph with the maximum overlap. It should be understood that after completing the bottleneck reliability evaluation of the candidate subgraphs, it is necessary to integrate the evaluation indicators of the two orthogonal dimensions of structural overlap and path reliability into a unified matching decision criterion. This is because structural overlap only reflects the sufficiency of the skills required for the new task in the historical graph, while bottleneck reliability only reflects the lower limit of the execution safety of the migration path. Both have information blind spots when used independently; a subgraph with high overlap but low reliability may experience link breakage during execution, while a subgraph with low overlap but high reliability has insufficient coverage and cannot provide sufficient prior knowledge for the new task. Therefore, in the technical solution of this application, a joint matching score is further performed on the candidate subgraph bottleneck reliability evaluation set based on the node intersection-union ratio overlap and the migration path bottleneck reliability to obtain the subgraph with the maximum overlap, thereby integrating structural coverage sufficiency and migration path execution safety into a unified two-dimensional joint decision criterion. In this way, it can be ensured that the final selected subgraph with the highest overlap not only has a broad coverage of the skill requirements of the new task, but also ensures that the weakest link of all internal migration paths is still maintained above an acceptable level of credibility. This allows the cross-task prior constraint template extracted from the subgraph to effectively reduce the decision uncertainty and physical execution failure risk in the skill switching process after being injected into the physical execution decision of the embodied agent.

[0048] More specifically, in a concrete example of this application, firstly, the system traverses each candidate subgraph in the candidate subgraph bottleneck reliability assessment set, and recalculates the Jaccard node overlap of each candidate subgraph using the standardized candidate skill subsequence set obtained by decomposing the new task skill sequence. The system extracts the set of skill nodes contained in each candidate subgraph, calculates the intersection cardinality and union cardinality between the skill node set and the standardized candidate skill subsequence set, and obtains the node intersection-union ratio overlap value of the candidate subgraph by dividing the intersection cardinality by the union cardinality.

[0049] Next, the system multiplicatively couples the node's intersection-union ratio overlap with the bottleneck reliability of the corresponding subgraph's migration path to calculate the structure-reliability joint matching score. The core calculation of the above joint matching score is expressed as follows: In the formula, Candidate subgraph Structure-reliability joint matching score, Candidate subgraph The set of skill nodes included This refers to the standardized candidate skill subsequence set obtained by decomposing the new task skill sequence. Candidate subgraph The formula defines the reliability value of the bottleneck in the migration path. The use of multiplication instead of addition for coupling in this formula has clear implications for physical execution constraints. The multiplicative structure ensures that when any dimension approaches zero, the overall score synchronously approaches zero. Even if the nodes in a subgraph have extremely high overlap, as long as there is a bottleneck migration edge with very low weight within it, the joint score will be significantly suppressed; conversely, the same applies. This characteristic precisely matches the rigid constraints of the embodied agent's physical execution: insufficient skill coverage leads to a lack of prior decision information, and unreliable paths may result in physical failure of skill switching; either failure mode will cause the overall task execution to be interrupted. Taking the evaluation of candidate subgraphs for VIP customized guided tour tasks as an example, candidate subgraph A contains three skill nodes: path planning, obstacle avoidance navigation, and voice guidance. Its node intersection-union ratio (IUU) overlap is 0.75, the bottleneck reliability of the migration path is 0.89, and the joint matching score is 0.75 × 0.89 = 0.6675. Candidate subgraph B contains two skill nodes: path planning and obstacle avoidance navigation. Its node IUU overlap is 0.4, but the migration edge weight from obstacle avoidance navigation to elevator interaction is extremely low, resulting in a bottleneck reliability of only 0.12, and the joint matching score is 0.4 × 0.12 = 0.048. Although candidate subgraph B has a certain coverage capability in the node overlap dimension, due to the extremely weak migration path within it, the multiplicative coupling mechanism significantly suppresses its joint score to an extremely low level, effectively avoiding the risk of injecting the uncertain causal constraints of weakly reliable subgraphs as priors into the decision-making process.

[0050] Then, the system selects the candidate subgraph with the highest joint score as the final output subgraph with the maximum overlap. The core formula for the optimal selection is expressed as: In the formula, This is the final output subgraph with the highest overlap. The retrieval space consists of all candidate subgraphs in the candidate subgraph bottleneck reliability evaluation set; The structure-reliability joint matching score is used for each candidate subgraph. The subgraph with the maximum overlap after joint weighted selection not only has a broad coverage of the skill requirements of the new task, but also ensures that the weakest link of all internal migration paths remains above acceptable reliability strength. This allows the cross-task prior constraint template extracted from this subgraph to effectively reduce the decision uncertainty and physical execution failure risk in the skill switching process after being injected into the physical execution decision of the embodied agent. Taking the above candidate subgraph evaluation results as an example, the system selects candidate subgraph A with a joint score of 0.6675 as the final output subgraph with the maximum overlap. In the skill migration link from path planning to obstacle avoidance navigation to voice guidance carried by this subgraph, each migration edge has been fully verified by historical counterfactual verification, and the bottleneck reliability of 0.89 indicates that the weakest link still has a high reliability strength.

[0051] In summary, by introducing a migration path bottleneck reliability assessment and a structure-reliability joint weighted matching optimization mechanism, the subgraph retrieval process of cross-task causal migration graphs is improved from a single node topology coverage statistics to a two-dimensional joint decision that considers both structural coverage sufficiency and migration path execution safety. In the actual physical execution scenario of embodied agents, the cross-task migration knowledge carried by the finally selected optimal subgraph not only highly matches the new task in terms of skill coverage, but also each skill switching channel within it has undergone sufficient historical counterfactual verification, eliminating the risk of physical execution link breakage caused by unreliable prior constraints introduced by weakly verified migration paths. Overall, the stability of skill chain switching and the first execution success rate of embodied agents when facing new tasks are significantly improved. The number of task retries triggered by the failure of prior constraints and the motion correction overhead in the multi-agent collaborative scheduling system are correspondingly reduced, thereby reducing the amount of invalid log data generated and the computational resource consumption of repeated distillation during the closed-loop iteration process.

[0052] Accordingly, in step 4.3, the validity of the maximum overlap matching subgraph is determined based on a preset overlap activation threshold. Specifically, prior logic constraints are extracted and templates are encapsulated for high-confidence causal chains in the subgraph exceeding the threshold to obtain cross-task prior constraint templates. It should be understood that although the maximum overlap matching subgraph obtained through joint weighted matching optimization performs optimally in terms of both structural coverage and path reliability, the historical experience it carries still needs final validity confirmation to ensure sufficient coverage to support the generation of high-quality prior constraint templates. If the skill coverage between the maximum overlap matching subgraph and the new task does not meet the minimum activation requirement, the forcibly extracted prior constraints will lack effective guidance for the new task's decision-making process due to insufficient coverage, and may even introduce erroneous decision biases due to one-sided constraints. Therefore, in the technical solution of this application, the validity of the maximum overlap matching subgraph is further determined based on a preset overlap activation threshold. Specifically, prior logic constraints are extracted and templates are encapsulated from the high-confidence causal chains in the subgraphs exceeding the threshold to obtain cross-task prior constraint templates. This ensures that specific prior constraints are generated only when historical experience coverage is sufficient, and high-confidence decision logic that has undergone sufficient counterfactual verification is extracted from these templates as execution guidance for new tasks. In this way, highly reliable causal logic constraints are injected into the new task decision-making process of the embodied agent, enabling the agent to obtain accurate guidance from historical experience in key aspects such as skill invocation timing, switching conditions, and execution boundaries. This significantly improves the first-time execution accuracy of new tasks. Simultaneously, for entirely new task types with insufficient historical experience coverage, a general relaxed constraint template is automatically reverted to avoid the introduction of erroneous priors.

[0053] More specifically, in a concrete example of this application, firstly, a preset overlap activation threshold is loaded. This threshold is used to determine whether the historical experience carried by the maximum overlap matching subgraph has sufficient skill coverage to support the effective generation of the prior constraint template. The system extracts the node intersection-union ratio overlap value calculated in the joint optimization process of the maximum overlap matching subgraph, and compares this overlap with the preset overlap activation threshold: when the overlap is greater than or equal to the activation threshold, the system determines that the skill coverage of the matching subgraph for the new task meets the minimum requirements for the generation of prior constraints, and proceeds to the subsequent high-confidence causal chain screening and logical constraint extraction process; when the overlap is lower than the activation threshold, the system determines that the new task belongs to a completely new task type that is highly unrelated to historical experience, and there is not enough reusable experience in the cross-task causal migration graph to support the generation of exclusive prior constraints. The system automatically reverts and calls the centrally preset general relaxed constraint template as the basic decision guide. This general relaxed constraint template only contains general safety constraint rules that do not depend on specific historical experience. Taking the VIP customized guided tour task as an example, the intersection-union ratio of the nodes in the matching subgraph with the maximum overlap is 0.75. The preset overlap activation threshold is set to 0.6. If the overlap exceeds this activation threshold, the system determines that the historical experience coverage is sufficient and enters the prior constraint extraction process.

[0054] Next, the system performs high-confidence causal chain filtering and logical constraint parsing on the subgraph with the highest overlap that passes the validity determination. The system extracts the source causal chains associated with all migration edges within the subgraph and retrieves the complete decision paths and corresponding counterfactually calibrated confidence scores of these source causal chains from the gated authorized causal memory set. The system sorts and filters the retrieved source causal chains by confidence score, retaining those with confidence scores exceeding a preset high-confidence threshold as objects for extracting prior logical constraints, and discarding those with insufficient confidence scores to avoid introducing insufficiently validated decision logic into prior constraints. The system then performs internal logical structure parsing on the retained high-confidence causal chains, extracting key decision logic information such as the temporal call relationships between skill nodes, the triggering preconditions of each skill node, the environmental state constraint thresholds during skill switching, and the fallback strategy under abnormal conditions. Taking the two migration edges from path planning to obstacle avoidance navigation and from obstacle avoidance navigation to voice guidance in the subgraph with the maximum overlap as an example, the system retrieved the confidence of the entire chain of the associated causal chain of the guide from the gating authorization causal memory set. The confidence of the entire chain of the security causal chain was 0.91 and 0.87, both of which exceeded the high confidence threshold. The system analyzed the logical constraints and extracted key decision-making logical constraints such as: after the path planning is completed, the distribution status of obstacles in the passage ahead must be confirmed before starting obstacle avoidance navigation; during the obstacle avoidance navigation process, if the width of the passage ahead is lower than the preset safety threshold, switch to voice guidance for waiting guidance; and if the duration of voice guidance exceeds the preset timeout threshold, trigger the path replanning backoff strategy.

[0055] Then, the extracted high-reliability causal logic constraints are structurally abstracted and templated to generate a cross-task prior constraint template specific to the current new task. The system encapsulates the extracted temporal call relationships into skill call recommendation sequences, the triggering preconditions into skill activation condition matrices, the environmental state constraint thresholds into skill switching boundary parameter sets, and the fallback strategies into exception handling rule tables. Finally, the above four types of structured information are packaged into a unified cross-task prior constraint template. This cross-task prior constraint template will be issued to the assigned agent's execution layer along with differentiated scheduling instructions in subsequent steps, enabling the agent to directly reuse historical high-reliability decision logic as execution guidance when facing a new VIP customized tour task. Taking the VIP customized guided tour task as an example, the generated cross-task prior constraint template includes the recommended sequence of skill invocation as the ordered execution sequence of path planning, obstacle avoidance navigation, and voice guidance. In the skill activation condition matrix, the precondition for starting obstacle avoidance navigation is that the obstacle distribution status has been confirmed. In the skill switching boundary parameter set, the trigger condition for voice guidance is that the width of the passage ahead is less than the 0.6-meter safety threshold. In the exception handling rule table, the timeout rollback strategy is to re-trigger path planning when voice guidance lasts for more than 30 seconds. Through this mechanism, when facing a new task, the agent no longer makes exploratory decisions from scratch, but executes skill invocation and switching under the precise guidance of highly reliable historical experience. The first execution accuracy has increased from 32% in the traditional solution to 58%. Moreover, with the continuous expansion and iteration of the cross-task causal transfer graph, the coverage and accuracy of the prior constraint template will further increase, achieving continuous emergent capability evolution.

[0056] Specifically, in step five, each agent executes tasks according to differentiated scheduling instructions and cross-task prior constraint templates, and uses kinematic error correction memory for motion compensation. The newly generated perception decision data is encapsulated into an embodied perception decision log stream, and the distillation depth is adaptively adjusted based on the agent's memory maturity before flowing back to step one to form a closed-loop iteration. It is understandable that, since the preceding steps have completed the generation of differentiated scheduling instructions and cross-task prior constraint templates, these decision-level instructions and constraints ultimately need to be implemented by the embodied agent in the physical world through actual motion control and skill execution. However, the chassis hardware of the embodied agent will accumulate systematic motion deviations during long-term operation. If the kinematic error correction memory obtained from distillation is not used to compensate for the physical execution process, even if the decision logic is correct, the agent will still experience physical execution failures such as path deviation, positioning drift, or misaligned skill switching due to systematic deviations at the motion control level. At the same time, the new perception and decision data generated during task execution needs to be effectively encapsulated and fed back to the distillation entry point to drive the next round of iteration. Furthermore, the log data generated by agents of different maturity levels should be processed with differentiated distillation depths to achieve an adaptive iterative strategy of stable accumulation for weak agents and rapid evolution for strong agents. Therefore, in the technical solution of this application, each agent executes tasks according to differentiated scheduling instructions and cross-task prior constraint templates, and uses kinematic error correction memory for motion compensation. The newly generated perceptual decision data is encapsulated into an embodied perceptual decision log stream. Based on the agent's memory maturity, the distillation depth is adaptively adjusted before flowing back to step one to form a closed-loop iteration. This eliminates the interference of systematic motion deviations on decision implementation at the physical execution level. Furthermore, the multi-dimensional new data generated during execution is flowed back to the hierarchical memory distillation entry point using an adaptive distillation depth strategy. This ensures that the correct logic at the decision level is accurately reproduced at the physical execution level. Simultaneously, differentiated distillation depth routing allows high-maturity agents' high-quality logs to directly enter the migration distillation channel to accelerate global graph expansion, while low-maturity agents' basic logs only enter the standard distillation channel to avoid noise diffusion from low-quality memories, forming a continuously self-accelerating, self-evolving closed-loop flywheel.

[0057] More specifically, in the embodiments of this application, step five includes: step 5.1, injecting kinematic error correction memory into the chassis control loop to systematically compensate for motion deviations in the physical execution process under the constraints of differentiated scheduling instructions and cross-task prior constraint templates to obtain multimodal control state feedback data; step 5.2, using a global hardware synchronous clock source to timestamp-align the multi-source sensor sequences in the multimodal control state feedback data to obtain an embodied perception decision log stream; step 5.3, based on the matching result of the agent's memory maturity and the preset distillation threshold range, writing the distillation depth routing identifier into the embodied perception decision log stream and then returning it to step one to form a self-evolving closed-loop iteration.

[0058] Specifically, in a concrete example of this application, after the system issues differentiated scheduling instructions and cross-task prior constraint templates, each agent enters the physical task execution phase and generates new perception and decision data. First, kinematic error correction memory is injected into the chassis control loop to systematically compensate for motion deviations in the physical execution process under the constraints of differentiated scheduling instructions and cross-task prior constraint templates. The specific implementation process is as follows: the chassis motion control module of each agent receives the sub-task execution target and resource quota parameters assigned in the differentiated scheduling instructions, and simultaneously loads the skill call recommendation sequence, skill activation condition matrix, and skill switching boundary parameter set encapsulated in the cross-task prior constraint template as pre-constraints for decision execution. After the physical motion control loop is started, the system reads the kinematic error correction memory obtained in step one, which contains systematic motion residual parameters identified and retained by the agent's chassis hardware during historical operation. The system injects the residual compensation amount from the kinematic error correction memory into the PID control loop of the chassis motor via feedforward compensation. This performs systematic deviation pre-compensation on the wheel speed control commands issued in each control cycle, ensuring that the actual motion trajectory approximates the theoretically planned trajectory after compensation. Driven by the compensated control quantity, each agent performs tasks such as physical movement, obstacle avoidance, and skill switching. Simultaneously, each sensor module collects multimodal control state feedback data in real time, including odometer pose increments, LiDAR point cloud distance sequences, wheel speed encoder feedback, and skill call timing records from the decision-making module. Taking the guide robot A, which is assigned to perform the VIP main passage tour task, as an example, the system injects the turning lateral offset compensation parameters recorded in its kinematic error correction memory into the chassis control loop. When performing obstacle avoidance navigation at the second floor corner, the reverse lateral correction amount is pre-added, so that the actual turning trajectory deviation is reduced from 0.24 meters before compensation to 0.03 meters. At the same time, the cross-task prior constraint template constrains it to automatically switch to voice guidance skills to wait for guidance when it detects that the width of the passage ahead is less than the 0.6-meter safety threshold. Throughout the entire execution process, each sensor continuously outputs multimodal control status feedback data.

[0059] Next, using a global hardware synchronous clock source, the timestamps of the multi-source sensor sequences in the multimodal control state feedback data are timestamped to obtain the embodied perception decision log stream. The specific implementation process is as follows: Since the odometer data, lidar point cloud data, wheel speed control command data, and task decision call record data in the multimodal control state feedback data come from different hardware sensor modules, and the sampling frequency and internal clock of each module have inherent differences, direct splicing would lead to data timing misalignment and an inability to correctly reconstruct the actual physical process of task execution. The system utilizes a global hardware synchronous clock source deployed on the intelligent agent's main control board to recalibrate and align the original timestamps of the sensor data from each channel with a unified nanosecond-level time base, eliminating timing drift between multi-source data. The system then structures and packages the timestamped odometer data, lidar point cloud data, wheel speed control command data, and task decision call record data according to a predefined log communication protocol format, encapsulating them into a standardized embodied perception decision log stream. The data format of this log stream is completely consistent with the input format in step one, ensuring that it can be directly parsed and processed by the hierarchical memory distillation module.

[0060] Then, based on the matching results between the agent's memory maturity and the preset distillation threshold range, the embodied perception decision log stream is written with a distillation depth routing identifier and then flows back to step one, forming a self-evolving closed-loop iteration. The specific implementation process is as follows: the system reads the agent's memory maturity calculated in step two, matches this maturity value with the preset distillation threshold range system, and determines the agent's current appropriate distillation depth level. The logic for determining the distillation depth level is expressed as follows: In the formula, To calculate the adaptive distillation depth level of the output; This represents the agent's agent memory maturity level. This is a preset basic distillation maturity threshold; This represents a preset high-order transfer maturity threshold. A distillation depth level of 1 means only basic tiered distillation at the cerebellar and cerebral levels is performed, and cross-task transfer functions are disabled to avoid amplifying noise from low-quality memories. A distillation depth level of 2 means that cross-task causal transfer analysis is initiated based on basic distillation to abstract existing task experience into a general constraint template. A distillation depth level of 3 means that high-confidence causal chains are synchronized to the global cross-task causal transfer graph based on deep distillation to support the reuse of agent experience across the entire platform. In this formula, the piecewise function structure ensures that agents at different maturity levels receive distillation processing depths that match their current capability levels. Log data from low-maturity agents undergoes only basic purification to stably accumulate basic experience; log data from medium-maturity agents undergoes deep distillation to accelerate experience abstraction; and log data from high-maturity agents directly triggers transfer distillation to contribute high-quality experience to the global graph, achieving a differentiated iterative strategy of stable accumulation for weak agents and rapid evolution for strong agents.

[0061] Furthermore, based on the determined distillation depth level, a corresponding distillation depth routing identifier is written into the data header of the embodied awareness decision log stream. This identifier will be parsed and read at the hierarchical memory distillation entry point in step one to determine which level of distillation processing channel the batch of log data will enter. The system will output the embodied awareness decision log stream with the routing identifier tagged back to the input end of step one, driving the execution of the next round of hierarchical memory distillation, completing the self-evolutionary closed-loop iteration. Taking the distillation depth routing of six agents as an example, the basic distillation maturity threshold is set to 0.4 and the high-order transfer maturity threshold is set to 0.8. The agent memory maturity of the tour guide robot A is 0.879, and the distillation depth level is judged as 3, which is transfer distillation. Its newly generated embodied perception decision log stream will directly enter the transfer distillation channel after the backflow. The newly added high-quality causal chain will be synchronized to the global cross-task causal transfer graph to expand the graph nodes and transfer edges. The agent memory maturity of the security robot D is 0.691, and the distillation depth level is judged as 2, which is deep distillation. After its log data is backflowed, cross-task experience abstraction will be initiated to generate a new causal structure constraint template. The agent memory maturity of the tour guide robot B is 0.282, and the distillation depth level is judged as 1, which is basic distillation. After its log data is backflowed, only the standard three-layer layered distillation is performed to complete the data purification. The cross-task transfer function is turned off to prevent low-quality memory from polluting the global graph.

[0062] In summary, the multi-embodied intelligent agent hierarchical memory collaborative self-evolution method according to the embodiments of this application is explained. Firstly, it purifies the embodied perception decision log stream through hierarchical memory by introducing three differentiated distillation mechanisms: kinematic residual constraints, counterfactual causal confidence calibration, and causal structure similarity clustering. This fundamentally solves the problems of high noise and loss of effective information in full-scale storage. Secondly, based on the causal chain confidence produced by distillation, it aggregates and calculates the agent's memory maturity in an endogenous manner, eliminating the subjectivity of manually preset weights and achieving accurate quantification of the agent's true decision-making ability. Based on this, a gradient-based task allocation is performed for multiple agents to solve the resource mismatch problem in the role matching scheduling mode. Secondly, a cross-task causal migration graph is constructed based on maturity gating, enabling high-quality historical experience to be reused across heterogeneous tasks and breaking through the generalization bottleneck of decision-making from scratch. At the same time, a joint matching mechanism of migration path bottleneck reliability and node overlap is introduced in the graph subgraph retrieval stage to avoid selecting weakly reliable subgraphs by a single coverage criterion, which would lead to execution failure. Finally, the distillation, maturity, scheduling and execution data are fed back to form a closed loop iteration to achieve multi-agent collaborative self-evolution.

[0063] The various embodiments of this disclosure have been described above. These descriptions are exemplary and not exhaustive, nor are they limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terminology used herein is chosen to best explain the principles, practical application, or improvement of the technology in the market, or to enable others skilled in the art to understand the embodiments disclosed herein.

Claims

1. A multi-agent hierarchical memory collaborative self-evolution method, characterized in that, include: Step 1: Through kinematic residual constraints, counterfactual causal confidence calibration, and causal structure similarity clustering, hierarchical memory distillation is performed on the embodied perception decision log stream to obtain kinematic error correction memory, causal chain confidence memory set, and causal structure constraint template. Step 2: Based on the confidence of each causal chain in the causal chain confidence memory set after counterfactual calibration, aggregate and measure it in an endogenous way without artificially preset weights to obtain the agent's memory maturity. Step 3: Based on the agent's memory maturity, dynamically reconstruct the cross-task causal transfer network graph by combining the causal chain confidence memory set and the causal structure constraint template to obtain the cross-task causal transfer graph. Step 4: Based on the agent's memory maturity, perform gradient task allocation for multiple agents, and perform maximum overlap subgraph matching on the new task skill sequence in the cross-task causal transfer graph to obtain differentiated scheduling instructions and cross-task prior constraint templates. Step 5: Each agent executes the task according to the differentiated scheduling instructions and cross-task prior constraint template, and uses kinematic error correction memory for motion compensation. The newly generated perception and decision data is encapsulated into an embodied perception and decision log stream. The distillation depth is adaptively adjusted based on the agent's memory maturity and then returned to Step 1 to form a closed loop iteration.

2. The multi-agent hierarchical memory collaborative self-evolution method according to claim 1, characterized in that, The embodied perception decision log stream includes odometer data, lidar point cloud data, wheel speed control command data, and task decision call record data.

3. The multi-agent hierarchical memory collaborative self-evolution method according to claim 1, characterized in that, Step one includes: Step 1.1: Based on the parameters of the kinematic forward model, perform cerebellar layer error incremental distillation on the odometer data and wheel speed control command data in the embodied perception decision log stream based on kinematic physical constraints to obtain kinematic error corrected memory. Step 1.2: Using alternative skills in the skill library, perform failure probability calibration and low-confidence path pruning on the positive causal chain of task decision call record data in the embodied perception decision log stream to obtain the causal chain confidence memory set. Step 1.3: Based on the subsequence overlap threshold, perform structural similarity clustering and common subsequence extraction on the continuous skill subsequences of each causal chain in the causal chain confidence memory set to obtain the causal structure constraint template.

4. The multi-agent hierarchical memory collaborative self-evolution method according to claim 1, characterized in that, Step two includes: Step 2.1: By setting a pre-defined confidence threshold, the confidence of each causal chain in the causal chain confidence memory set is filtered for validity and counted to obtain the high-confidence causal chain confidence set and the number of valid causal memories; Step 2.2: Based on the number of effective causal memories, perform endogenous decision certainty accumulation calculation on each confidence level in the high-confidence causal chain confidence set to obtain the decision certainty accumulation value; Step 2.3: Perform maturity mapping on the cumulative decision certainty value to obtain the agent's memory maturity.

5. The multi-agent hierarchical memory collaborative self-evolution method according to claim 1, characterized in that, Step three includes: Step 3.1: Based on the preset high-order transfer threshold, the agent's memory maturity is gating qualification to screen the causal chain confidence memory set and causal structure constraint template, so as to obtain the gating authorized causal memory set and gating authorized constraint template. Step 3.2: By matching and retrieving the shared continuous skill subsequences among heterogeneous causal chains, cross-task association edges are constructed and geometric average weights are assigned to the gated authorization causal memory set and the gated authorization constraint template to obtain candidate migration nodes and weighted edge sets; Step 3.3 involves incremental topological fusion and smoothing correction of repeated edge weights between the candidate migration nodes and the set of weighted edges and the existing global graph to obtain a cross-task causal migration graph.

6. The multi-agent hierarchical memory collaborative self-evolution method according to claim 1, characterized in that, Step four includes: Step 4.1: Based on the high, medium and low gradient levels of agent memory maturity, priority matching and assignment and computing power and bandwidth weighted allocation are performed on multiple agents and subtasks of different complexities to obtain differentiated scheduling instructions. Step 4.2: Using the standardized candidate skill subsequences obtained from the decomposition of the new task skill sequence as retrieval conditions, perform global subgraph traversal and intersection-union ratio (IUU) overlap quantification on the cross-task causal migration graph to obtain the matching subgraph with the maximum overlap. Step 4.3: The validity of the matching subgraph with the maximum overlap is determined based on the preset overlap activation threshold. The high-confidence causal chain in the subgraph exceeding the threshold is subjected to prior logic constraint extraction and template encapsulation to obtain cross-task prior constraint template.

7. The multi-agent hierarchical memory collaborative self-evolution method according to claim 1, characterized in that, Step five includes: Step 5.1: Inject kinematic error correction memory into the chassis control loop to systematically compensate for motion deviations in the physical execution process under the constraints of differentiated scheduling commands and cross-task prior constraint templates, so as to obtain multimodal control state feedback data. Step 5.2: Use a global hardware synchronization clock source to timestamp-align the multi-source sensor sequences in the multimodal control state feedback data to obtain the embodied perception decision log stream; Step 5.3: Based on the matching results of the agent's memory maturity and the preset distillation threshold range, the embodied perception decision log stream is written with a distillation depth routing identifier and then flows back to step one to form a self-evolutionary closed-loop iteration.

8. The multi-agent hierarchical memory collaborative self-evolution method according to claim 6, characterized in that, Step 4.2 includes: Based on a preset overlap threshold, candidate subgraphs that overlap with new task skill sequence nodes in the cross-task causal migration graph are screened and the minimum weight of internal migration edges is extracted to obtain a candidate subgraph bottleneck reliability evaluation set. Based on the node intersection-union ratio overlap and migration path bottleneck reliability, a joint matching score is used to optimize the candidate subgraph bottleneck reliability evaluation set to obtain the matching subgraph with the maximum overlap.

Images