One agent's memory, and the question a second agent adds.
Memory for a single autonomous agent is a write-manage-read loop: what gets stored, how it is organized, and how it is retrieved on a later turn. A 2026 survey of the field formalizes exactly that loop and organizes the mechanisms behind it along three axes — how long information persists, what form it takes in storage, and what policy controls its use (arXiv:2603.07670).
Multi-agent memory keeps that loop and adds one question a single agent never has to answer: what happens when a second agent reads or writes the same state. That question is a topology choice, not a storage-format choice, and it is where the isolated/shared/hybrid distinction below comes from.
Isolated, shared, or hybrid.
Once more than one agent is involved, memory design reduces to a choice among three topologies.
| Topology | Description |
|---|---|
| isolated | Each agent keeps a local memory and exchanges information with the others through explicit messages, such as a dialogue history or a task handoff. Nothing is read or written outside an agent's own store. Avoids cross-agent interference, at the cost of redundancy (the same fact stored more than once) and inconsistency (one agent revises a belief the others never see). |
| shared | All agents read and write a common store, such as a shared document, a global vector index, or a blackboard that agents monitor and contribute to indirectly. Removes redundancy and lets any agent see any other agent's update, at the cost of contention, staleness, and the question of who is allowed to read or write what. |
| hybrid / two-tier | Each agent keeps a private memory alongside access to a shared memory, with an access policy governing what crosses from one tier to the other. The practical middle ground between the two extremes above, and the shape most governed multi-agent systems converge on. |
What each topology costs.
Isolated memory's costs are named consistently across recent surveys of multi-agent LLM systems: avoiding interference between agents comes at the price of redundancy, the same fact independently stored by more than one agent, and inconsistency, a belief one agent revises without the others ever seeing the change.
Shared memory trades those costs for a different set. A 2026 proposal for governed shared memory in multi-agent LLM systems names four recurring failure modes once several agents read and write a common store concurrently: unauthorized leakage (an agent reads what it should not), stale propagation (an update reaches some agents before others), contradiction persistence (two agents' beliefs disagree and neither is resolved), and provenance collapse (a stored fact's origin is lost) (arXiv:2606.24535). A separate line of work frames the same territory as a computer- architecture problem, distinguishing shared from distributed memory paradigms and proposing a layered hierarchy — an I/O layer, a cache layer, and a memory layer — for reasoning about where state should live (arXiv:2603.10062).
A hybrid design does not eliminate these costs so much as scope them: a two-tier system in which each agent keeps private memory alongside a shared tier, gated by an access policy, has been proposed specifically to let knowledge transfer where it is wanted while keeping sensitive or per-agent context out of the shared tier by default (arXiv:2505.18279).
A governed shared topology, not a coordination feature.
Substrate memory falls on the shared side of the spectrum above: a population of agents reads and writes one typed graph rather than keeping separate local stores. Two of the four shared-memory failure modes named in the prior section map directly onto its primitives. Append-only supersession, in which a changed entry is never edited in place but linked to a new one that replaces it, keeps a contradiction as a dated, ordered pair rather than letting it silently persist unresolved. Typed authorship on every entry, recording who wrote it and when, gives a stored fact a traceable origin rather than an anonymous one.
Coordination among agents follows from that structure rather than being a separate mechanism added to it: a population of ephemeral agents stays coherent because each one reads back a graph that already reflects what the others decided, not because a scheduling or messaging layer keeps them in sync. The architecture of how that plays out, role by role, is covered separately; see coordinating agents through shared memory.
Common questions.
Is multi-agent memory just single-agent memory used by more agents?
No. A single agent reading and writing its own history raises no sharing question. Multi-agent memory begins where a second agent needs to read or write the same state, which introduces a topology choice (isolated, shared, or hybrid) and, in the shared case, questions of access, staleness, and contradiction that a single-agent store never has to answer.
Is shared memory always better than isolated memory?
Not straightforwardly. Isolation avoids interference between agents but risks redundancy and silent inconsistency. Sharing removes both, but introduces contention over who can read or write what, and how a stale or contradicted entry is handled once more than one agent can change it. Most governed systems land on a hybrid: private memory per agent, shared memory where warranted.
What goes wrong in a naive shared-memory design?
A 2026 architecture proposal for governed shared memory in multi-agent LLM systems names four recurring failure modes: unauthorized leakage, stale propagation, contradiction persistence, and provenance collapse (arXiv:2606.24535). Each maps to a design question — who can read what, how old is too old, what happens when two agents disagree, and where a piece of memory came from.
Where does substrate memory sit in this taxonomy?
Substrate memory is one governed-shared-memory design. Its append-only supersession keeps a superseded entry rather than overwriting it, addressing contradiction persistence directly; its typed authorship on every entry addresses provenance. Coordination among agents is a consequence of that structure rather than a separate mechanism layered on top. See coordinating agents through shared memory.