eachmind: Why Your Multi-Agent System Needs Private Memory

Every multi-agent framework gives agents a shared memory pool. Same context, same perspective, same blind spots. You get task division, not team cognition. The opposite — fully isolated agents — kills collaboration entirely. eachmind is a per-agent memory protocol that solves this: private memory by default, selective sharing by design, genuine perspective divergence as a feature.

Current agent swarms share a single memory system. Every agent draws from the same pool of context, producing the same perspective. This creates the illusion of collaboration — agents divide tasks but never truly think differently from each other. An analyst agent and a writer agent looking at the same quarterly report should not reach the same conclusion in the same way. But with shared memory, they do. Every time.

The alternative — fully isolated agents — is worse. No learning from each other. No institutional knowledge. No ability to build on shared experience. You need something in between: agents that think independently but can selectively share when it matters.

eachmind defines six core primitives that govern how memory is stored, differentiated, and selectively shared across agents. It is a protocol layer — not a vector database, not an agent framework, not a replacement for Mem0 or Zep. Any agent system can adopt it.

This is the core insight. When two agents observe the same MemoryEvent — say, "Q1 revenue grew 23% YoY" — the analyst encodes statistical significance and trend implications, while the writer encodes narrative angle and audience framing. Neither encoding is wrong. Both are useful. And when the analyst decides to share a synthesised finding with the team, the writer receives it as shared knowledge — not as a replacement for their own perspective.

from eachmind import Agent, MemoryEvent, SharedMemory

# Create agents with their own private memory
analyst = Agent(name="analyst", role="data analysis")
writer = Agent(name="writer", role="content creation")

# Both observe the same event
event = MemoryEvent(
    content="Q1 revenue grew 23% YoY",
    source="quarterly_report",
    timestamp="2026-04-10T09:00:00Z"
)

# Each encodes it through their own perspective
analyst.observe(event)  # Statistical significance, trends
writer.observe(event)   # Narrative angle, audience framing

# Analyst shares a finding — deliberately
analyst.share(
    content="Revenue growth acceleration suggests market expansion",
    to=SharedMemory.TEAM
)

# Perspectives naturally drift — and that's measurable
drift = analyst.perspective.drift_from(writer.perspective)

Raw memory events are not the end state. Over time, repeated observations consolidate into durable beliefs — abstractions that the agent carries forward without needing to re-derive them from scratch. An analyst that has processed 50 quarterly reports does not just remember 50 data points. It has formed a model of what "normal growth" looks like, what outliers mean, and which metrics actually predict outcomes. This is Consolidation: the mechanism that turns experience into expertise.

In a healthy team, people develop different perspectives over time — even when exposed to the same information. eachmind makes this measurable through the Drift primitive. You can quantify how far two agents' perspectives have diverged, identify when a team is converging too tightly (groupthink risk), or detect when an agent's worldview has shifted significantly from its original role definition. Drift is not a bug to fix. It is a signal to monitor.

eachmind works alongside OpenAI Agents SDK, CrewAI, LangGraph, or a hand-written agent loop — no lock-in. Storage backends include in-memory, SQLite, and Redis out of the box. It sits as a protocol layer above your existing memory backends (Mem0, Zep, MemGPT), defining how agents interact with memory rather than how memory is physically stored.

eachmind is Project 1 of 2. All core primitives, protocol specification, storage backends, drift visualisations, and integration examples are implemented and shipped. Project 2 is the agent architecture built on top — a system where agents genuinely challenge, review, disagree, and accumulate institutional knowledge over time. Not agents that divide tasks. Agents that think differently and argue productively.