MultiAgentMemory: Shared and Asymmetric Memory for Multi-Agent LangChain Workflows

[dmitrykazhdan]

🧠 Feature Proposal: MultiAgentMemory for Multi-Agent LangChain Agents

Problem

Current LangChain memory implementations (e.g., ConversationBufferMemory, ChatMessageHistory) are well-suited for single-agent or single-chain applications. However, as LangGraph and multi-agent workflows are becoming more-and-more common, there's a growing need for multi-agent memory management.

This can start with built-in abstraction for:

• Per-agent private memory
• Shared memory (global facts, shared state, etc.)
• Access control (e.g., publish/subscribe to shared memory)
• Tracking what each agent knows or has revealed

Proposed Solution Outline: MultiAgentMemory

A memory module with the following properties:

• MultiAgentMemory(agent_ids: List[str], config: Dict)
• Each agent has:
  • Private memory (standard message history or custom memory class)
  • Shared memory (optional, controlled visibility)
• Agents can:
  • Write to their own memory
  • Publish to shared memory
  • Optionally read from shared memory or specific agents' memories (with access rules)
• Optional support for:
  • Memory store backend (in-memory or Redis/VectorStore)
  • Structured schema for shared memory (e.g., Fact, Event, ChatMessage)

Example Use Case

Consider a LangGraph flow simulating agents in a social deduction game:

• Agent A discovers a fact (e.g. "The glass tile on the left is safe")
• Agent A chooses whether to share it
• Agent B, depending on its memory access, either knows or infers this
• All agents evolve their beliefs over time, with memory guiding their next actions

This could enable new LLM workflows involving:

• Multi-agent RAG
• Asymmetric game simulations
• Belief modelling & Theory-of-Mind LLM experiments

Integration Plan

If the maintainers agree on the design, I can:

• Implement MultiAgentMemory under langchain/memory/
• Extend from core BaseMemory
• Write unit tests + integration tests with LangGraph flow
• Provide one or two example notebooks or Colab demos

Happy to adapt based on feedback 🙏

[onestardao]

Great write-up. Multi-agent memory is going to be a bottleneck without a shared framework for resolving semantic conflict and latent contradiction between agents.

I've experimented with multi-agent RAG and game-like inference chains, and one persistent issue is that shared memory tends to accumulate noise, redundancy, or even false consensus unless there's a regulating engine for:

• Semantic consistency validation
• Temporal logic tracing (what was known, when, and by whom)
• Epistemic weight adjustment (who "trusts" what)

Without such regulation, shared memory just becomes a growing JSON blob with no inference power.

I've built a working memory controller that handles these edge cases — including implicit memory rewrites based on downstream agent behaviors. Happy to share insights if anyone wants to compare architectures.

(I do maintain a full diagnostic/problem map for these issues, but I don’t share links unless asked — just keeping it clean.)

[dmitrykazhdan]

Awesome to hear @onestardao! 🙌
Lets see if @baskaryan (or Team) decide to prioritise this direction 🤞

[onestardao]

Thanks for the response! I'm curious if there's already a design doc or WIP direction around memory arbitration in LangGraph.

If this moves forward, I'd be happy to contribute a few reference implementations or edge case demos — especially around semantic divergence and downstream agent memory rewrites (e.g. belief updates or asymmetric recall).

Totally fine to wait if the team is still evaluating — just keeping an eye on this with interest.