A distributed multi-agent cooperative memory synchronization system and method

Abstract

The application provides a distributed multi-agent collaborative memory synchronization system and method, the system comprising a session access layer, an agent execution layer, an asynchronous synchronization layer, a local memory layer, a global shared memory layer and a memory management layer; the session access layer receives user requests and triggers a read-through process, and before calling a target agent, retrieves relevant context from a short-term memory unit and a local long-term memory unit in the local memory layer and the global shared memory layer; the agent execution layer comprises a plurality of heterogeneous agent instances; the local memory layer comprises a short-term memory unit and a local long-term memory unit; the asynchronous synchronization layer realizes cross-agent memory synchronization through a write-back queue, an asynchronous Worker and a shared digest recalculation mechanism; and the memory management layer controls the credibility, timeliness and injection range of memory entries through a source confidence level classification, a time decay, a conflict arbitration and an on-demand recall mechanism.

Description

Technical Field

[0001] This invention relates to the field of multi-agent collaborative technology, specifically to a distributed multi-agent collaborative memory synchronization system and method. Background Technology

[0002] With the rapid development of large language model technology, automated systems centered on a single agent have gradually evolved into multi-agent systems where multiple agents with heterogeneous functions collaborate. In these systems, multiple agents with different functional roles and professional capabilities are integrated into a unified collaborative framework, working together through division of labor and interaction to complete highly complex automated tasks. Multi-agent systems, with their ability to decompose and execute tasks, diverse perspectives, and concurrent processing advantages, have demonstrated significant value in numerous general scenarios such as intelligent customer service, automated process handling, knowledge-based question answering, and complex decision support, and have become an important development direction for current artificial intelligence system architecture.

[0003] However, when existing theoretical frameworks are applied to multi-agent scenarios, they face unique challenges not present in single-agent memory solutions: multiple heterogeneous agents maintain their own memories independently, easily leading to information silos; cross-agent knowledge sharing lacks a unified consistency guarantee mechanism; the reliability of memories varies due to differences in data sources; and the lack of weight decay of old memories over time leads to the accumulation of contextual noise, thereby reducing the actual utilization rate of large language models. Existing systems generally lack systematic solutions for multi-agent scenarios, making it difficult to support efficient, reliable, and low-noise memory collaboration among multiple heterogeneous agents. Summary of the Invention

[0004] To address the shortcomings of existing technologies, the present invention aims to provide a distributed multi-agent collaborative memory synchronization system and method. By constructing a complete hierarchical heterogeneous multi-agent memory synchronization technology system, it achieves efficient, reliable, and low-noise context-aware memory management in multi-agent systems.

[0005] To solve the above problems, the technical solution of the present invention is as follows:

[0006] A distributed multi-agent collaborative memory synchronization system includes a session access layer, an agent execution layer, an asynchronous synchronization layer, a local memory layer, a global shared memory layer, and a memory governance layer. The session access layer receives user requests and triggers a read-through process. Before invoking the target agent, it retrieves relevant context from the short-term memory units and local long-term memory units in the local memory layer, as well as from the global shared memory layer. The agent execution layer contains multiple heterogeneous agent instances. Each agent, when executing a task, reads relevant memories from the local memory layer and shared states from the global shared memory layer, and generates interaction records and candidate memory entries upon completion of the response. The local memory layer contains... The system includes short-term memory units and local long-term memory units; the global shared memory layer is used to store the global state summary, intent recognition summary, and key shared knowledge after summary compression; the asynchronous synchronization layer realizes cross-agent memory synchronization through write-back queues, asynchronous workers, and shared summary recalculation mechanisms; the memory governance layer controls the credibility, timeliness, and injection scope of memory entries through source confidence grading, time decay, conflict arbitration, and on-demand recall mechanisms; each layer transmits requests, responses, memory change events, and feedback states through a unified message bus, forming a complete system covering memory reading, agent execution, asynchronous write-back, shared synchronization, conflict handling, and on-demand recall.

[0007] Preferably, the short-term memory unit adopts a sliding window mechanism to store the most recent N rounds of original dialogue records in the current session with a fixed window length N. Before each agent call, the original dialogue records are injected with prompt words in chronological order to support intra-session referencing resolution and contextual coherence. The local long-term memory unit uses a triple consisting of user identifier, agent identifier, and memory type as the primary key. It stores personalized historical information formed between the agent and a specific user in a structured manner according to preference class, blocking point class, and interaction habit class. Each record includes content text, source level, initial confidence weight, write timestamp, most recent hit timestamp, and hit count.

[0008] Preferably, the functions of the asynchronous synchronization layer include: after each agent completes a round of interaction, the system writes the original dialogue record of this round into a storage table and submits the task to the asynchronous waiting queue; after the asynchronous worker retrieves the task, it calls the language model to perform structured memory retrieval. If new preferences, blocking points, or interaction habit entries are generated, they are inserted into the long-term memory table in an ADD-only manner, and important global state changes are written into the shared memory waiting queue; write-back triggers are divided into timed triggers and key event triggers. When recalculating the summary, the summary is weighted and merged according to the source level, and the language model is called to generate a new summary, which is then fully overwritten and written into the shared memory table.

[0009] Preferably, the memory governance layer is used to: set a source level and initial confidence weight for memory entries based on their source; calculate effective weights based on the most recent hit time and time decay coefficient of memory entries, and filter memory entries with effective weights lower than a preset threshold; when semantic conflicts occur between new and old memory entries, perform substitution, pending review, or decay processing on the corresponding entries based on the source level and timestamp; and screen and sort candidate memories based on the semantic topic, memory type, and effective weight of the current request.

[0010] Furthermore, the present invention also provides a distributed multi-agent cooperative memory synchronization method, comprising the following steps:

[0011] Deploy and initialize the dual-track hierarchical memory architecture;

[0012] Perform memory retrieval during the session initiation phase;

[0013] Memory writing after a single round of interaction is completed;

[0014] Conduct confidence level arbitration and conflict resolution;

[0015] Perform shared memory summary recalculation.

[0016] Preferably, the steps for deploying and initializing the dual-track hierarchical memory architecture specifically include: during system deployment, allocating an independent local long-term memory storage area in persistent storage for each agent instance, and establishing a structured storage table with user identifier, agent identifier, and memory type triple as the primary key dimension; each local long-term memory record includes the following fields: content text, source level, initial confidence weight, write timestamp, most recent hit timestamp, and hit count; in the global shared memory layer, establishing a shared memory storage structure with user identifier and summary type as the primary key, wherein the summary type includes two categories: global capability profile and intent recognition summary, and the corresponding fields are fully covered each time it is recalculated; the short-term memory units in the local memory layer reuse the session message storage structure, and extract the most recent N rounds of dialogue records in timestamp order to form a sliding window.

[0017] Preferably, the memory retrieval step in the session initiation phase specifically includes: after the user initiates a session and the system routes to the target agent, the following retrieval process is executed before calling the language model: first, two types of summaries are retrieved from the global shared memory layer according to the user identifier and concatenated into the context area of ​​the system prompt word; then, according to the user identifier and agent identifier, the local long-term memory unit of the corresponding agent in the local memory layer is queried, and all candidate memory entries are obtained. The effective weight of each memory is recalculated according to the decay formula, and entries with weights lower than the threshold are filtered out; if the on-demand recall mode is enabled, the remaining candidate entries are further filtered by BM25 according to the semantic topic keywords of the current request, and the Top-K entries are selected; finally, the sliding window content in the short-term memory unit of the local memory layer is written into the dialogue history area of ​​the prompt word in chronological order to complete the prompt word construction and submit it for language model inference.

[0018] Preferably, the step of writing memory after a single round of interaction specifically includes: after the agent completes a round of response, the system executes the following asynchronous writing process: writes the original dialogue record of this round into the original dialogue storage table; simultaneously submits a writing task to the waiting queue of the asynchronous worker, carrying the dialogue content of this round; when the asynchronous worker executes, it calls the language model to extract the dialogue content in the queue, extracting the semantics of the prompt words: determining whether the current round of dialogue has generated new preferences, new blocking points, or new interaction habits, returning null if none, and returning a structured entry if yes; if the extraction result is not empty, the new entry is inserted into the long-term memory table in an ADD-only manner, and important global state changes are written into the shared memory waiting queue, waiting to be included in the next summary recalculation.

[0019] Preferably, the steps of confidence arbitration and conflict handling specifically include: before writing a new memory entry, the asynchronous worker searches for existing entries with similar semantics in the same dimension; if a semantic conflict is detected, the system arbitrates according to the following rules: if the source level of the new entry is higher than that of the old entry, the old entry is marked as invalid and replaced by the new entry; if the source level of the new entry is lower than that of the old entry, the new entry is marked as pending review, without overwriting the old entry, and awaits further confirmation by subsequent high-confidence events; if the source levels are the same, the entry with the newer timestamp is retained, and the old entry enters the decay process.

[0020] Preferably, the step of recalculating the shared memory summary specifically includes: the shared memory summary recalculation is triggered by a scheduled task or a key event. During the recalculation, the system collects all state update entries in the queue to be processed, merges them by source hierarchy, and calls the language model to perform summary generation on the merged original data to generate a new global capability profile summary and intent recognition summary; each summary conclusion field carries a confidence score and a generation timestamp; the new summary is written to the shared memory table in a full-coverage manner, replacing the old version summary.

[0021] Compared with the prior art, the present invention has at least the following beneficial effects:

[0022] 1. This invention uses a dual-track hierarchical architecture to clearly separate working memory (short-term sliding window), experience memory (local long-term memory), and factual memory (global shared memory). This ensures the contextual coherence within a single agent session and enables knowledge accumulation and sharing across agents and sessions. It eliminates information silos at the architectural level and significantly improves the overall contextual awareness of the system.

[0023] 2. This invention, through a write-back / read-through bidirectional synchronization protocol, ensures that new knowledge states generated by any intelligent agent can be promptly transmitted to the global shared memory and take effect immediately upon the next intelligent agent's access. Supported by a source tagging mechanism, the receiving intelligent agent can perceive the source of information and perform differentiated processing. This mechanism effectively eliminates information contradictions during cross-agent decision-making and improves the overall collaborative consistency of the system.

[0024] 3. This invention proposes a four-layer confidence rating system (L1–L4), assigning different initial weights to each memory entry based on the objectivity of the data source, and prioritizing entries from high-confidence sources during conflict arbitration. This mechanism effectively suppresses the interference of low-confidence information on agent decision-making, improving the robustness and reliability of the memory system.

[0025] 4. This invention introduces a time decay mechanism based on an exponential decay model, where the effective weight of memory automatically decreases over time, and low-weight entries are automatically removed from the injection candidate set. This mechanism maintains the timeliness and signal-to-noise ratio of the context, effectively improving the reasoning accuracy of large language models in long interaction scenarios and preventing agents from making incorrect judgments based on outdated information. Attached Figure Description

[0026] Other features, objects, and advantages of the present invention will become more apparent from the following detailed description of non-limiting embodiments with reference to the accompanying drawings:

[0027] Figure 1 This is a diagram illustrating the overall architecture of the distributed multi-agent collaborative memory synchronization system of the present invention.

[0028] Figure 2 This is a flowchart of the distributed multi-agent collaborative memory synchronization method of the present invention. Detailed Implementation

[0029] The present invention will now be described in detail with reference to specific embodiments. These embodiments will help those skilled in the art to further understand the present invention, but do not limit the invention in any way. It should be noted that those skilled in the art can make several changes and improvements without departing from the concept of the present invention. These all fall within the protection scope of the present invention.

[0030] Specifically, the present invention provides a distributed multi-agent collaborative memory synchronization system, such as... Figure 1 As shown, the system includes a session access layer, an agent execution layer, a local memory layer, a global shared memory layer, an asynchronous synchronization layer, and a memory governance layer.

[0031] The session access layer receives user requests and triggers a readthrough process. Before invoking the target agent, it retrieves relevant context from the short-term memory and local long-term memory units in the local memory layer, as well as from the global shared memory layer. The agent execution layer contains multiple heterogeneous agent instances. Each agent reads relevant memories from the local memory layer and shared states from the global shared memory layer when executing tasks, and generates interaction records and candidate memory entries after the response is completed. The local memory layer includes short-term memory units and local long-term memory units. The short-term memory units are used to maintain the current session context, and the local long-term memory units are used to maintain long-term personalized experiences formed between each agent and a specific user. The global shared memory layer is used to store global state summaries, intent recognition summaries, and key shared knowledge after digest compression. The asynchronous synchronization layer achieves cross-agent memory synchronization through write-back queues, asynchronous workers, and shared digest recalculation mechanisms. The memory governance layer controls the credibility, timeliness, and injection scope of memory entries through source confidence grading, time decay, conflict arbitration, and on-demand recall mechanisms. Each layer transmits requests, responses, memory change events, and feedback states through a unified message bus, forming a complete system covering memory retrieval, agent execution, asynchronous write-back, shared synchronization, conflict handling, and on-demand recall.

[0032] To address the problem of a lack of hierarchical isolation in memory architecture, this invention constructs a dual-track hierarchical memory architecture, dividing the entire memory system into two levels: a local memory layer and a globally shared memory layer.

[0033] The local memory layer is maintained independently by each agent instance and includes short-term memory units and local long-term memory units. The short-term memory unit uses a sliding window mechanism, storing the most recent N rounds of original dialogue records in the current session with a fixed window length N. Before each agent call, the original dialogue records are injected with prompt words in chronological order to support in-session referencing resolution and contextual coherence, corresponding to the function of working memory. The local long-term memory unit uses a triple consisting of user identifier, agent identifier, and memory type as the primary key. It structures and stores personalized historical information formed between the agent and a specific user according to preference class, blocking point class, and interaction habit class. Each record includes content text, source level, initial confidence weight, write timestamp, most recent hit timestamp, and hit count, corresponding to the function of experience memory. The global shared memory layer maintains a shared memory space accessible to all agents. Using user identifier and summary type as the primary key, it stores the user's global state after summary compression, including a global capability profile summary and an intent recognition summary, corresponding to the function of fact memory. Each time the summary is recalculated, the corresponding summary content is fully overwritten. To address the lack of an effective synchronization mechanism for cross-agent memory sharing, this invention designs and implements a write-back / read-through bidirectional synchronization protocol, coupled with an asynchronous Worker mechanism to ensure that synchronization operations do not block the user response link. Regarding the write-back mechanism: after each agent completes a round of interaction, the system writes the original dialogue record of that round into a storage table and submits the task to the asynchronous waiting queue; after the asynchronous Worker retrieves the task, it calls the language model to perform structured memory retrieval. If new preferences, blocking points, or interaction habit entries are generated, they are inserted into the long-term memory table in an ADD-only manner, and important global state changes are written into the shared memory waiting queue; write-back triggers are divided into two categories: timed triggers (performing summary recalculation at fixed intervals) and key event triggers (triggered immediately when the user completes a stage task node). During summary recalculation, the summary is weighted and merged according to the source level (L1–L4), and then the language model is called to generate a new summary, which is then fully overwritten and written into the shared memory table. Regarding the read-through mechanism: Before each agent is invoked, the system retrieves two types of shared summaries and the agent's local long-term memory entries (filtered with effective weights) based on the user identifier, and uniformly injects system prompts to ensure that each agent obtains a globally consistent user state view before generating a response. In addition, each entry written back into the shared memory carries a source tag (written with the agent identifier and timestamp), supporting other agents to perceive the source of information, perform differentiated confidence judgments, and realize cross-agent knowledge tracing.

[0034] To address the lack of a hierarchical evaluation mechanism for memory reliability, this invention proposes a four-layer confidence rating system (L1–L4) based on the objectivity of data sources. Each memory entry is assigned an initial confidence weight upon writing, and arbitration is performed according to these weights in the event of multi-source conflicts. The definitions of each layer are as follows: L1 - Authoritative Evidence (W0 = 0.9), derived from objective evaluation events within the system, possessing the highest objectivity and directly usable as a basis for inference; L2 - Interactive Inference (W0 = 0.6), derived from semantic inference in multi-turn interactions between the agent and the user, possessing high reliability but with inference errors; L3 - Behavioral Statistics (W0 = 0.4), derived from user behavior logs, only proving the occurrence of behavior, not directly proving state transitions; L4 - Self-Description (W0 = 0.2), derived from static profiles actively submitted by users, possessing strong subjectivity, serving only as an initial reference value, and continuously decreasing in weight as dynamic data accumulates. When a new entry conflicts semantically with an existing entry, the system arbitrates according to the following rules: if the new entry has a higher source level, the old entry is marked as invalid and replaced by the new entry; if the new entry has a lower source level, the new entry is marked as pending review and does not overwrite the old entry; if the source levels are the same, the entry with the newer timestamp is retained, and the old entry enters the decay process. The system never performs simple overwriting and retains a traceable arbitration history through a soft marking mechanism.

[0035] To address the problem of inadequate memory timeliness management, this invention introduces a time decay weight mechanism based on an exponential decay model for each entry in both the shared memory layer and the long-term memory layer. This mechanism automatically reduces the confidence level of memory validity over time, preventing outdated information from occupying the context window for extended periods. The decay formula is defined as follows:

[0036]

[0037] Where W(t) is the current effective weight; W0 is the initial weight determined by the L1–L4 hierarchical system at the time of writing; t is the time elapsed from the most recent hit to the current moment; λ is the decay coefficient, with the λ value of dynamic state memory being higher than that of static preference memory. During the memory injection phase, the system recalculates W(t) for each candidate item in real time: items with weights below the lower threshold are not injected with the current prompt word (the database record is retained for reactivation); items with weights in the warning range are marked with a question mark during injection, allowing the agent to initiate proactive confirmatory questions to the user; items with weights above the lower threshold are injected normally. Each time an item is hit, the system updates its most recent hit time and recalculates the weight, achieving a closed loop of dynamic memory activation and decay.

[0038] To address the issues of low efficiency and lack of on-demand retrieval capabilities in memory recall, this invention designs and implements a lightweight on-demand memory recall mechanism. This mechanism converges the number of memory tokens containing the injected prompts to the minimum necessary set most relevant to the current request, effectively suppressing context corruption. The recall process consists of three steps: First, topic keyword extraction: before each agent call, a language model performs semantic analysis on the current user input to generate a set of semantic keyword tags. Second, two-dimensional filtering recall: filtering is performed on the memory storage based on a two-dimensional dimension (memory type + semantic topic keywords). This supports parallel execution and fusion sorting of two strategies: BM25-style keyword matching based on full-text index (implemented using the built-in full-text index of a relational database, eliminating the need for an independent vector library) and classification filtering based on source tags. Third, effective weight reordering: candidate entries are sorted in descending order of effective weight W(t), and the top-K injected prompts are selected, prioritizing the retention of high-weight, highly relevant entries. This mechanism follows the principle of "minimum high-signal token set" to ensure that each injected memory serves the specific reasoning purpose of the current request, fundamentally avoiding the problems of attention dilution and reasoning quality degradation caused by context inflation.

[0039] Furthermore, the present invention also provides a distributed multi-agent cooperative memory synchronization method, such as... Figure 2 As shown, the method includes the following steps:

[0040] S1: Deploy and initialize the dual-track hierarchical memory architecture;

[0041] Specifically, during system deployment, in the local memory layer, each agent instance is allocated an independent local long-term memory storage area in persistent storage, and a structured storage table is established using the user identifier, agent identifier, and memory type triple as the primary key. Each long-term memory record contains the following fields: content text, source level (L1–L4), initial confidence weight, write timestamp, most recent hit timestamp, and hit count. The global shared memory uses the user identifier and summary type as the primary key. The summary type is divided into two categories: global capability profile summary and intent recognition summary, and the corresponding fields are fully overwritten each time it is recalculated. The short-term memory units in the local memory layer reuse the existing session message storage structure without the need for additional table creation, and form a sliding window by sorting the most recent N records by timestamp.

[0042] S2: Perform memory retrieval during the session initiation phase;

[0043] Specifically, after a user initiates a session and the system routes the request to the target agent, the following reading process is executed before invoking the language model: First, two types of summaries are retrieved from the global shared memory layer based on the user identifier and appended to the context area of ​​the system prompt word; then, the local long-term memory units of the corresponding agent in the local memory layer are queried based on the user identifier and agent identifier, and all candidate memory entries are obtained. The effective weight of each memory is recalculated according to the decay formula, and entries with weights below the threshold are filtered out; if the on-demand recall mode is enabled, the remaining candidate entries are further filtered using BM25 based on the semantic topic keywords of the current request, and the Top-K entries are selected; finally, the sliding window content in the short-term memory unit of the local memory layer is written into the dialogue history area of ​​the prompt word in chronological order to complete the prompt word construction and submit it for language model inference.

[0044] S3: Memory write after a single round of interaction is completed;

[0045] Specifically, after the agent completes a round of responses, the system executes the following asynchronous write process: The original dialogue record (user input + agent output) of this round is written to the original dialogue storage table; simultaneously, a write task carrying the content of this round of dialogue is submitted to the asynchronous worker's waiting queue. When the asynchronous worker executes, it calls the language model to perform memory retrieval of the dialogue content in the queue, extracting the semantics of the prompt words: determining whether this round of dialogue has generated new preferences, new blocking points, or new interaction habits; if not, it returns null; otherwise, it returns a structured entry. If the extraction result is not empty, the new entry is inserted into the long-term memory table in an ADD-only manner, and important global state changes are written to the shared memory waiting queue, waiting to be included in the next summary recalculation.

[0046] S4: Conduct confidence level arbitration and conflict resolution;

[0047] Specifically, before writing to a new memory entry, the asynchronous worker searches for existing entries with similar semantics within the same dimension. If a semantic conflict is detected, the system arbitrates according to the following rules: if the source level of the new entry is higher than that of the old entry (e.g., new entry L1, old entry L3), the old entry is marked as invalid and replaced by the new entry; if the source level of the new entry is lower than that of the old entry, the new entry is marked as pending review, without overwriting the old entry, and awaits further confirmation from subsequent high-confidence events; if the source levels are the same, the entry with the newer timestamp is retained, and the old entry enters the decay process.

[0048] S5: Perform shared memory digest recalculation.

[0049] Specifically, the shared memory summary recalculation is triggered by a scheduled task or a critical event. During recalculation, the system collects all state update entries in the processing queue, weights and merges them according to their source level (L1–L4), and then calls the language model to generate a summary on the merged original data, producing a new global capability profile summary and intent recognition summary. Each summary conclusion field carries a confidence score (calculated by source weighting) and a generation timestamp. The new summary is written to the shared memory table in a full-overwrite manner, replacing the old version summary. Conclusions in the summary field with a confidence score below the threshold are marked as questionable, and the agent can use this to determine whether it needs to initiate active confirmation with the user when reading.

[0050] Specific embodiments of the present invention have been described above. It should be understood that the present invention is not limited to the specific embodiments described above, and those skilled in the art can make various changes or modifications within the scope of the claims, which do not affect the essence of the present invention. Unless otherwise specified, the embodiments and features described in this application can be arbitrarily combined with each other.

Claims

1. A distributed multi-agent cooperative memory synchronization system, characterized in that, The system comprises a session access layer, an agent execution layer, an asynchronous / synchronous layer, a local memory layer, a global shared memory layer, and a memory governance layer. The session access layer receives user requests and triggers a read-through process. Before invoking the target agent, it retrieves relevant context from the short-term memory and local long-term memory units in the local memory layer, as well as from the global shared memory layer. The agent execution layer contains multiple heterogeneous agent instances. Each agent, when executing a task, reads relevant memories from the local memory layer and shared states from the global shared memory layer, and generates interaction records and candidate memory entries upon completion of the response. The local memory layer includes short-term memory units and local long-term memory units. The global shared memory layer is used to store the global state summary, intent recognition summary, and key shared knowledge after summary compression; the asynchronous synchronization layer realizes cross-agent memory synchronization through write-back queue, asynchronous worker, and shared summary recalculation mechanism. The memory governance layer controls the credibility, timeliness, and injection scope of memory entries through source confidence grading, time decay, conflict arbitration, and on-demand recall mechanisms. Each layer transmits requests, responses, memory change events, and feedback status through a unified message bus, forming a complete system covering memory reading, agent execution, asynchronous write-back, shared synchronization, conflict handling, and on-demand recall.

2. The distributed multi-agent cooperative memory synchronization system according to claim 1, characterized in that, The short-term memory unit adopts a sliding window mechanism to store the original dialogue records of the most recent N rounds of the current session with a fixed window length N. Before each agent call, the original dialogue records are injected with prompt words in chronological order to support intra-session referencing resolution and contextual coherence. The local long-term memory unit uses a triple consisting of user identifier, agent identifier and memory type as the primary key. It stores the personalized historical information formed between the agent and a specific user in a structured manner according to preference class, blockage point class and interaction habit class. Each record includes content text, source level, initial confidence weight, write timestamp, most recent hit timestamp and hit count.

3. The distributed multi-agent cooperative memory synchronization system according to claim 1, characterized in that, The functions of the asynchronous-synchronous layer include: after each agent completes a round of interaction, the system writes the original dialogue record of this round into the storage table and submits the task to the asynchronous waiting queue; after the asynchronous worker retrieves the task, it calls the language model to perform structured memory retrieval. If new preferences, blocking points, or interaction habit entries are generated, they are inserted into the long-term memory table in an ADD-only manner, and important global state changes are written into the shared memory waiting queue; write-back triggers are divided into timed triggers and key event triggers. When recalculating the summary, it calls the language model to generate a new summary after weighted merging according to the source level, and writes it into the shared memory table with full coverage.

4. The distributed multi-agent cooperative memory synchronization system according to claim 1, characterized in that, The memory governance layer is used to: set the source level and initial confidence weight of memory entries based on their source; calculate the effective weight based on the most recent hit time and time decay coefficient of memory entries, and filter memory entries with effective weights lower than a preset threshold; when a semantic conflict occurs between new and old memory entries, perform replacement, pending review, or decay processing on the corresponding entries based on the source level and timestamp. And it filters and sorts candidate memories based on the semantic topic, memory type, and effective weight of the current request.

5. A distributed multi-agent cooperative memory synchronization method, characterized in that, The method includes the following steps: Deploy and initialize the dual-track hierarchical memory architecture; Perform memory retrieval during the session initiation phase; Memory writing after a single round of interaction is completed; Conduct confidence level arbitration and conflict resolution; Perform shared memory summary recalculation.

6. The distributed multi-agent cooperative memory synchronization method according to claim 5, characterized in that, The steps for deploying and initializing the dual-track hierarchical memory architecture specifically include: during system deployment, allocating an independent local long-term memory storage area in persistent storage for each agent instance, and establishing a structured storage table with user identifier, agent identifier, and memory type triple as the primary key dimension; each local long-term memory record contains the following fields: content text, source level, initial confidence weight, write timestamp, most recent hit timestamp, and hit count; in the global shared memory layer, establishing a shared memory storage structure with user identifier and summary type as the primary key, the summary type including two categories: global capability profile and intent recognition summary, with the corresponding fields fully covered each time recalculated; the short-term memory units in the local memory layer reuse the session message storage structure, and extract the most recent N rounds of dialogue records in timestamp order to form a sliding window.

7. The distributed multi-agent cooperative memory synchronization method according to claim 5, characterized in that, The steps for memory retrieval during the session initiation phase specifically include: after the user initiates a session and the system routes to the target agent, the following retrieval process is executed before calling the language model: first, two types of summaries are retrieved from the global shared memory layer according to the user identifier and appended to the context area of ​​the system prompt word; then, according to the user identifier and agent identifier, the local long-term memory unit of the corresponding agent in the local memory layer is queried, and all candidate memory entries are obtained. The effective weight of each memory is recalculated according to the decay formula, and entries with weights lower than the threshold are filtered out; if the on-demand recall mode is enabled, the remaining candidate entries are further filtered using BM25 according to the semantic topic keywords of the current request, and the Top-K entries are selected; finally, the sliding window content in the short-term memory unit of the local memory layer is written into the dialogue history area of ​​the prompt word in chronological order to complete the prompt word construction and submit it for language model inference.

8. The distributed multi-agent cooperative memory synchronization method according to claim 5, characterized in that, The memory writing steps after a single round of interaction are specifically as follows: After the agent completes a round of response, the system executes the following asynchronous writing process: writes the original dialogue record of this round into the original dialogue storage table; simultaneously submits a writing task to the pending queue of the asynchronous worker, carrying the dialogue content of this round; when the asynchronous worker executes, it calls the language model to perform memory extraction on the dialogue content in the queue, extracting the semantics of the prompt words: determining whether the current round of dialogue has generated new preferences, new blocking points, or new interaction habits; if not, it returns null; if so, it returns a structured entry; if the extraction result is not empty, the new entry is inserted into the long-term memory table in an ADD-only manner, and important global state changes are written into the shared memory pending queue, waiting to be included in the next summary recalculation.

9. The distributed multi-agent cooperative memory synchronization method according to claim 5, characterized in that, The steps for confidence arbitration and conflict handling specifically include: before writing a new memory entry, the asynchronous worker searches for existing entries with similar semantics in the same dimension; if a semantic conflict is detected, the system arbitrates according to the following rules: if the source level of the new entry is higher than that of the old entry, the old entry is marked as invalid and replaced by the new entry; if the source level of the new entry is lower than that of the old entry, the new entry is marked as pending review, without overwriting the old entry, and awaits further confirmation by subsequent high-confidence events; if the source levels are the same, the entry with the newer timestamp is retained, and the old entry enters the decay process.

10. The distributed multi-agent cooperative memory synchronization method according to claim 5, characterized in that, The steps for recalculating the shared memory summary specifically include: the shared memory summary recalculation is triggered by a scheduled task or a key event. During the recalculation, the system collects all state update entries in the queue to be processed, merges them by source hierarchy, and then calls the language model to generate a summary on the merged original data, generating a new global capability profile summary and intent recognition summary; each summary conclusion field carries a confidence score and a generation timestamp; the new summary is written to the shared memory table in a full-coverage manner, replacing the old version summary.

Images