Multi-Agent Memory Sharing and Synchronization: A Comprehensive Research Report (2024–2026)

1. Introduction and Scope

The period from 2024 to 2026 has seen multi-agent memory transition from a niche concern into one of the defining challenges of agentic AI. Where single-agent memory asks “how do I remember?”, multi-agent memory asks harder questions: who can see what, how do concurrent writes merge, and how do agents with different specializations transfer knowledge without losing fidelity?

This report covers four pillars: shared memory stores, message-passing memory updates, consensus protocols for conflicting memories, and framework-level implementations across CrewAI, AutoGen, LangGraph, and the broader ecosystem.

---

2. Architectural Taxonomy: How Agents Organize Memory

A March 2026 position paper from a computer architecture perspective (Multi-Agent Memory from a Computer Architecture Perspective) proposes a three-layer model that has become the dominant conceptual framework:

Layer	Function	Examples
I/O Layer	Ingests and emits information (text, images, API calls)	Tool interfaces, sensors
Cache Layer	Fast, limited-capacity storage for immediate reasoning	KV caches, compressed context, recent tool calls
Memory Layer	Large-capacity persistent storage optimized for retrieval	Vector databases, knowledge graphs, document stores

Two fundamental paradigms emerge from this model:

Shared Memory: All agents access a unified pool (e.g., a shared vector store or knowledge graph). This is simple to reason about but requires coherence mechanisms to prevent stale reads and conflicting overwrites.

Distributed Memory: Each agent owns local memory and synchronizes selectively. This improves isolation and scalability but demands explicit coordination to prevent divergence.

Most production systems in 2025-2026 implement hybrid architectures: agents maintain private working memory while reading from and writing to a shared long-term store, often through an orchestrator that mediates access.

---

3. Shared Memory Stores

3.1 The Blackboard Pattern (Revived)

The blackboard architecture, originally introduced by Hayes-Roth in 1985, has experienced a significant revival in LLM multi-agent systems. Two 2025 papers formalize the pattern for modern agent systems:

• LLM-Based Multi-Agent Blackboard System (2025): A central agent posts requests to a shared blackboard; autonomous subordinate agents volunteer to respond based on their capabilities. Results show 13-57% relative improvements in end-to-end success over strong baselines.

• Exploring Advanced LLM Multi-Agent Systems Based on Blackboard Architecture (July 2025): Agents communicate exclusively through the blackboard, which is divided into public and private spaces. The paper removes individual agent memory modules entirely, using the blackboard as unified storage. A dedicated conflict-resolver agent detects contradictions among messages, names the conflicting agents, and forces them into private debate spaces to reconcile before publishing updated messages to the public area.

The blackboard model’s key insight: by routing all communication through a single shared structure, you get automatic observability and can insert arbitration logic at one point rather than across every agent pair.

3.2 Centralized State Objects

LangGraph implements the most sophisticated centralized state approach among production frameworks. Its architecture uses:

• TypedDict-based state schemas with Annotated types defining reducer functions for each field
• Immutable versioning: when an agent updates state, a new version is created rather than altering the existing one
• Reducer-driven merging: custom functions control how concurrent updates combine (e.g., operator.add for list concatenation, add_messages for deduplication by message ID)
• Checkpointing: robust state snapshots enabling resumption after failures and safe parallel task execution

As documented in the LangGraph Architecture Guide, the reducer system ensures “deterministic merging semantics for concurrent and incremental updates” – a property critical when multiple graph nodes write to the same state keys simultaneously.

3.3 Vector Stores and Knowledge Graphs as Shared Memory

Mem0 (arxiv.org/abs/2504.19413) provides a production-grade shared memory layer that combines vector-based semantic search with graph memory for entity relationships. It maintains hierarchical memory scoped at user, session, and agent levels. Benchmarks show 91% lower p95 latency and 90%+ token cost savings versus full-context approaches, with a 26% improvement in LLM-as-a-Judge metrics over OpenAI baselines.

Zep (arxiv.org/abs/2501.13956) takes a temporal knowledge graph approach via its Graphiti engine. Unlike static vector stores, every fact in Zep has a validity window showing when it became true and when it was superseded. Entities evolve over time with updated summaries, and everything traces back to episodic source data. This temporal awareness is critical for multi-agent scenarios where agents operate asynchronously and must reason about the recency and validity of shared knowledge. Zep achieves up to 18.5% accuracy improvements over baselines on the LongMemEval benchmark.

3.4 Letta/MemGPT: Memory Blocks as Shared Units

Letta (formerly MemGPT) introduced the concept of Memory Blocks – discrete, labeled, size-constrained units of context that are individually persisted in a database with unique block_id identifiers. The critical multi-agent feature: multiple agents can reference the same block. When a background agent updates a shared block, the change is immediately available to all agents whose context window compiles from that block. This creates a primitive but effective shared memory mechanism without requiring a separate synchronization protocol.

---

4. Message-Passing Memory Updates

4.1 Conversation History as Implicit Memory

The simplest form of message-passing memory is the shared conversation log. AutoGen pioneered this with its group chat pattern, where a centralized Group Chat Manager (itself an LLM-powered agent) orchestrates turn-taking and all agents observe the full conversation history. In AutoGen v0.4 (Microsoft Research), the architecture was redesigned around an actor model with asynchronous messaging supporting both event-driven and request/response patterns. The Memory protocol provides five core methods (add, query, update_context, clear, close) with pluggable backends including ChromaDB, Redis, and Mem0.

4.2 Structured Message Protocols

Four interoperability protocols have emerged (surveyed in A Survey of Agent Interoperability Protocols), each with different implications for memory:

Protocol	Creator	State Model	Memory Implications
MCP	Anthropic (Nov 2024)	Stateless with optional context	Resources and prompts enable context injection but not inter-agent memory sharing
ACP	IBM Research (2025)	Session-aware with run state tracking	Session-level persistence ensures continuity; supports multimodal message parts
A2A	Google (Apr 2025)	Session-aware and stateless modes	Agents collaborate without sharing internal memory; artifacts serve as tangible output exchange
ANP	Community	Stateless with DID-authenticated tokens	Decentralized identity, no explicit memory-sharing mechanisms

A critical observation from the survey: none of these four protocols define a unified memory synchronization standard. They handle communication and task delegation, but the question of how agents share persistent knowledge remains outside their scope.

The Unified ACP paper (February 2026) proposes going beyond context sharing with a four-layered framework (Transport, Semantic, Negotiation, Governance) that includes federated discovery via distributed hash tables backed by consortium blockchain, and a Proof-of-Intent security mechanism. However, this remains a research proposal rather than a deployed standard.

4.3 Intrinsic Memory Agents

The Intrinsic Memory Agents paper (2025) introduces a pattern where each agent maintains role-specific structured memory templates (JSON schemas with slots like domain_expertise, current_position, proposed_solution). Memory updates occur through prompted LLM operations that integrate each agent’s outputs with its existing memory after every conversation turn. Crucially, agents exchange knowledge implicitly through a shared conversation space while maintaining heterogeneous private memories. This achieved a 38.6% improvement over the next-best memory architecture on PDDL planning benchmarks.

---

5. Consensus Protocols for Conflicting Memories

This is the least mature area and the most active research frontier.

5.1 The Problem Space

As the computer architecture perspective paper states, the challenge is “harder than classical settings because memory artifacts are heterogeneous (evidence, tool traces, plans), and conflicts are often semantic and coupled to environment state.” Traditional database consistency models do not map cleanly to natural-language memory stores where two agents might record contradictory conclusions that are both partially correct.

The Memory for Autonomous LLM Agents survey identifies the concurrent write problem explicitly: “In shared or hybrid memories, concurrent writes require conflict-resolution rules: the system must decide whose update takes precedence and whether to merge competing entries.”

5.2 Emerging Resolution Strategies

Event Sourcing: Rather than resolving conflicts on the final state, capture the full history of memory mutations. This preserves reasoning provenance, enables retroactive re-resolution, and aligns with memory distillation processes. This is the approach advocated by several 2025 papers as most natural for agentic systems.

Semantic Conflict Resolution via Arbiter Agents: The blackboard architecture paper deploys a dedicated conflict-resolver agent that detects contradictions, identifies the conflicting agents, moves them to a private space for debate, and publishes the reconciled result. This is the most common pattern in practice.

Role-Adaptive Retrieval: Rather than resolving conflicts at write time, systems resolve at read time by scoping retrieval to agent roles. An orchestrator retrieves global state, planners retrieve strategic memories, and workers retrieve localized skill-specific entries. Multi-resolution summaries keep both global and agent-specific views.

CRDTs for Agent Coordination: The CodeCRDT system (2025) is the most significant work applying distributed systems primitives to agent memory. Using Yjs CRDTs over WebSocket relay, it achieves:
- Zero character-level merge conflicts through deterministic convergence
- Last-Writer-Wins (LWW) register semantics for task claiming with optimistic write-verify
- Three CRDT types: Y.Text for documents, Y.Map for agent assignments, Y.Array for append-only audit trails
- Strong Eventual Consistency (SEC): all agents that receive the same updates converge to identical state without central coordination

However, CodeCRDT found a 5-10% semantic conflict rate even with zero character-level conflicts – duplicate declarations, type mismatches, and logical contradictions that required separate evaluator agents to reconcile. This result demonstrates that syntactic convergence is necessary but insufficient for multi-agent memory consistency.

Temporal Versioning: Zep’s approach – attaching validity windows to every fact – provides a form of temporal conflict resolution where newer facts supersede older ones while preserving the historical record. This is effective for factual knowledge but less suited to contradictory opinions or strategies.

5.3 What Is Missing

The research consensus as of early 2026 is that no principled, general-purpose consensus protocol for multi-agent LLM memory exists. The ICLR 2026 MemAgents Workshop identifies this as a primary open problem. Specific gaps include:

• No standardized cache-sharing protocol across agents (identified as a critical missing component)
• No standardized memory access control protocol (read-only vs read-write, granularity of access)
• No formal model for semantic conflict detection beyond ad-hoc LLM prompting
• No equivalent of distributed database isolation levels for agent memory transactions

---

6. Framework Implementations Compared

6.1 CrewAI

CrewAI implements a unified Memory class that replaced separate short-term, long-term, entity, and external memory types with a single intelligent API. Key multi-agent features:

• Hierarchical scoping: filesystem-like paths (/project/alpha, /agent/researcher) enable agents to share crew-level memory or receive private scoped views
• Composite scoring: retrieval blends semantic similarity (weight 0.5), recency (0.3), and importance (0.2)
• Non-blocking writes: remember_many() submits to background threads; recall() automatically drains pending writes before searching
• Privacy controls: memories carry source tags and private flags; private memories are only visible when the source matches

Storage defaults to LanceDB. The primary limitation, as noted by MemU: CrewAI does not persist the collaboration intelligence that emerges during teamwork. Optimal delegation patterns discovered during one execution are lost when it ends.

6.2 AutoGen (v0.4)

AutoGen v0.4 (Microsoft Research) provides a pluggable Memory protocol with implementations including ListMemory, ChromaDBVectorMemory, RedisMemory, and Mem0Memory. Agents receive memory instances via constructor parameter, and during execution emit MemoryQueryEvent to automatically integrate retrieved content as system messages.

For multi-agent coordination, AutoGen relies on conversation patterns (group chat, sequential, nested) rather than shared memory stores. The Group Chat Manager mediates turn-taking, but memory remains agent-specific. This is the most conversation-centric approach among major frameworks – knowledge sharing happens through dialogue rather than shared databases.

6.3 LangGraph

LangGraph’s state management system is the most sophisticated for multi-agent coordination:

• Explicit reducer-driven schemas using Python TypedDict and Annotated types
• Immutable state versioning creating new versions on every update
• MongoDB integration (2025) for cross-session persistent long-term memory
• Checkpoint-based recovery enabling resumption after failures

LangGraph’s approach is closest to a proper distributed state machine. Every agent reads from and writes to a central state object, with reducer logic preventing data loss from concurrent updates. This makes it the strongest choice for production workflows requiring fault tolerance and precise state management.

6.4 CAMEL

CAMEL provides ChatHistoryMemory for sequential context and VectorDBMemory for semantic search. Designed for systems with potentially millions of agents, it emphasizes communication topology over shared memory. The Workforce module builds teams of agents, and the Society module handles inter-agent interaction, but memory coordination is less formalized than in LangGraph or CrewAI.

6.5 Comparative Summary

Capability	CrewAI	AutoGen v0.4	LangGraph	CAMEL
Shared memory store	Unified Memory with scoping	Pluggable protocol (agent-specific)	Central state object with reducers	Vector + chat history
Conflict resolution	Consolidation threshold (0.85)	Conversation-mediated	Reducer functions	Not formalized
Persistence	LanceDB (default)	ChromaDB, Redis, Mem0	Checkpoints + MongoDB	Vector DB
Privacy/scoping	Hierarchical paths + source tags	Metadata filtering	State key access	Not formalized
Cross-session memory	Limited (does not persist collaboration patterns)	Via external stores	MongoDB long-term memory	Via external stores
Concurrency model	Non-blocking writes with drain-on-read	Actor model (async messaging)	Immutable versioning + reducers	Communication topology

---

7. Dedicated Memory Platforms (Cross-Framework)

Several framework-agnostic memory platforms have emerged to serve as shared memory infrastructure:

Platform	Architecture	Multi-Agent Strength	Key Metric
Mem0	Vector + graph, cloud/self-hosted	Hierarchical scoping (user/session/agent)	91% lower p95 latency vs full-context
Zep/Graphiti	Temporal knowledge graph	Validity windows on all facts	18.5% accuracy gain on LongMemEval
Letta	OS-inspired memory blocks	Shared block references across agents	~83.2% on LoCoMo
SuperLocalMemory	Local-first, four-channel retrieval	Privacy-focused, no native sharing	87.7% on LoCoMo (Mode C)

---

8. Open Problems and Research Directions

The Memory for Autonomous LLM Agents survey and the March 2026 position paper converge on these unsolved challenges:

1. Memory Access Protocol: No standard specifying permissions, scope, and granularity for multi-agent memory access. Should access be read-only vs read-write? At what granularity (documents, chunks, records, trace segments)?

2. Cache Coherence for Agents: Emerging KV cache sharing work (DroidSpeak, Cache-to-Cache, KVComm) but no principled protocol for sharing cached artifacts across agents.

3. Semantic Conflict Detection: Beyond syntactic convergence, agents need mechanisms to detect when their conclusions are logically contradictory – not just textually different. No formal model exists.

4. Selective Forgetting: Learning which memories to discard under safety and compliance constraints, particularly across shared stores where one agent’s deletion affects others.

5. Causal Retrieval: Moving beyond semantic similarity to identify upstream causal relationships in shared memory – a prerequisite for effective collaborative reasoning.

6. Scalability Limits: CodeCRDT demonstrates optimal performance at 3-5 agents, degrading to break-even at approximately 20 agents due to CRDT metadata overhead and context invalidation. Scaling shared memory to large agent swarms remains unsolved.

7. Governance and Audit: Privacy leakage, deletion compliance, and auditable access trails across shared memory tiers – particularly important for enterprise and regulated deployments.

---

9. Conclusion

Multi-agent memory in 2024-2026 is characterized by a proliferation of practical solutions without theoretical convergence. The field has moved from “agents share a conversation log” to sophisticated architectures involving temporal knowledge graphs, CRDT-based coordination, hierarchical scoped stores, and reducer-driven state machines. However, the fundamental protocols – how agents negotiate memory access, resolve semantic conflicts, and maintain consistency guarantees – remain ad-hoc and framework-specific.

The most promising near-term direction is the convergence of ACP and A2A under the Linux Foundation (September 2025), which could eventually incorporate memory federation alongside task delegation. Meanwhile, production systems must choose between LangGraph’s reducer-driven determinism, CrewAI’s scoped unified memory, AutoGen’s conversation-mediated sharing, or cross-framework platforms like Mem0 and Zep.

The CodeCRDT finding – zero syntactic conflicts but 5-10% semantic conflicts – may be the most important result of this period. It demonstrates that the hard problem of multi-agent memory is not synchronization (distributed systems solved that decades ago) but semantic coherence: ensuring that multiple agents reasoning independently arrive at, or can be reconciled toward, a consistent understanding of the world.

---

Sources:
- Multi-Agent Memory from a Computer Architecture Perspective (March 2026)
- Memory for Autonomous LLM Agents: Mechanisms, Evaluation, and Emerging Frontiers (March 2026)
- CrewAI Memory Documentation
- Intrinsic Memory Agents: Heterogeneous Multi-Agent LLM Systems (2025)
- LangGraph Agent Memory Architecture
- LangGraph Multi-Agent Orchestration Guide 2025
- Exploring Advanced LLM Multi-Agent Systems Based on Blackboard Architecture (July 2025)
- LLM-Based Multi-Agent Blackboard System (2025)
- CodeCRDT: Observation-Driven Multi-Agent Coordination (2025)
- Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory
- Zep: A Temporal Knowledge Graph Architecture for Agent Memory (January 2025)
- Letta Memory Blocks
- AutoGen v0.4 Memory and RAG
- AutoGen v0.4 Redesign (Microsoft Research)
- A Survey of Agent Interoperability Protocols: MCP, ACP, A2A, ANP
- Beyond Context Sharing: A Unified ACP (February 2026)
- Google A2A Protocol Announcement
- A2A Protocol v0.3 Upgrade
- CAMEL Framework (GitHub)
- CrewAI vs LangGraph vs AutoGen vs OpenAgents (February 2026)
- 5 AI Agent Memory Systems Compared (2026 Benchmark)
- ICLR 2026 MemAgents Workshop Proposal
- MongoDB + LangGraph Long-Term Memory
- MemU on CrewAI Collaboration Memory Limitations