Ingest: Multi-Agent Memory from a Computer Architecture Perspective

Type: scientific-paper

Source: multi-agent-memory-computer-architecture-perspective.md Captured: 2026-03-13 From: https://arxiv.org/html/2603.10062v1

Classification

Type: scientific-paper — Position paper from UC San Diego / Georgia Tech with formal structure, citations, and architectural proposals. Not empirical (no experiments), but fits the scientific paper mold as a structured theoretical contribution with literature survey.

Domains: multi-agent-systems, memory-architecture, context-engineering, agent-coordination

Author: Zhongming Yu et al. (UC San Diego, Georgia Tech) — systems architecture researchers applying hardware memory paradigms to LLM agents. The computer architecture background is the distinctive angle; they bring vocabulary and models (cache coherence, consistency protocols, shared vs. distributed memory) from a mature engineering discipline.

Summary

This position paper argues that multi-agent memory management should be understood through the lens of computer architecture rather than ad hoc system design. It proposes two fundamental paradigms (shared memory, where all agents access a common pool requiring coherence support, vs. distributed memory, where each agent maintains local memory with selective synchronization), introduces a three-layer hierarchy (I/O for ingestion/emission, cache for fast limited-capacity reasoning, memory for large persistent storage), and identifies two critical protocol gaps (no standardized cache sharing, no standardized memory access permissions). The paper's central claim is that multi-agent memory consistency — analogous to hardware cache coherence — is the most urgent unresolved challenge for scalable agent systems, made harder than classical settings because agent artifacts are heterogeneous and conflicts carry semantic rather than bitwise weight.

Connections Found

The /connect discovery found 10 genuine connections (6 strong, 4 moderate) and rejected 6 candidates.

Strong connections: - agentic-memory-systems-comparative-review — extends: The paper provides architectural theory (paradigms, hierarchy, consistency) that complements the review's empirical six-dimension analysis of 11 systems. The review's finding that no system combines high agency, high throughput, and high curation quality is exactly the consistency gap this paper identifies. - three-space-agent-memory-maps-to-tulving-taxonomy — extends: Two independent decompositions of agent memory from different traditions (cognitive science vs. computer architecture). Together they suggest a two-axis taxonomy: content type (what kind of knowledge) x hierarchy level (access speed/capacity). - llm-context-is-composed-without-scoping — grounds: The paper's multi-agent consistency challenge is the same structural problem as single-agent flat-context scoping, at a different scale. Both are shared mutable state without coordination primitives. - context-efficiency — extends: The paper's three-layer hierarchy is the multi-agent generalization of single-agent context scarcity, adding inter-agent coherence as a third dimension. - SAGE and Hindsight — exemplified by: Both are concrete implementations of concepts the paper describes theoretically (consensus-validated writes, four-way retrieval + two-level consolidation).

Moderate connections: memory-management-policy-is-learnable-but-oracle-dependent (AgeMem's LTM/STM maps to cache/memory layers), conversation-vs-prompt-refinement (maps to shared vs. distributed paradigm), two-context-boundaries (multi-agent generalization of two-boundary model), synthesis-is-not-error-correction (consistency failure explains 17.2x error amplification).

Synthesis opportunities flagged: 1. A two-axis memory taxonomy combining content-type (Tulving) and hierarchy-level (computer architecture) — would synthesize three-space-agent-memory and this paper. 2. A coordination-primitives note unifying context scoping and multi-agent consistency as instances of the same shared-mutable-state problem.

Extractable Value

  1. Shared vs. distributed memory paradigm as design lens — Naming this distinction for agent systems gives us vocabulary to classify existing systems and predict their failure modes. Every system we've reviewed maps onto this spectrum. [quick-win]

  2. Three-layer hierarchy (I/O / cache / memory) — An independent decomposition that complements the Tulving-based three-space model. The hierarchy is about access characteristics (latency, capacity, persistence) rather than content type, and could predict which content types belong at which layer. [experiment] — worth testing whether the two-axis model (content-type x hierarchy-level) produces better architectural predictions than either axis alone.

  3. Memory consistency as the critical unsolved problem — The paper names the specific gap: when does a write become visible to other agents, and how are semantic conflicts resolved? This reframes our existing observations about multi-agent error amplification (Kim et al.'s 17.2x) as consistency failures rather than synthesis failures. [deep-dive] — would require surveying consistency models from distributed systems literature and mapping them to agent coordination patterns.

  4. Protocol gaps (cache sharing, memory access) — Two specific missing standards: no principled way for agents to share cached artifacts, and no standardized permissions/scope/granularity for shared memory. These are concrete engineering targets. [just-a-reference] — useful for framing but the paper doesn't propose solutions.

  5. Consistency is harder for agents than for hardware — Artifacts are heterogeneous and conflicts carry semantic weight, not just bitwise differences. This is a substantive observation that explains why importing hardware consistency models directly won't work. [quick-win] — worth noting in existing memory-related notes as a caveat.

  6. Scoping and consistency are the same problem at different scales — The connection analysis surfaced this: single-agent context scoping (llm-context-is-composed-without-scoping) and multi-agent consistency are both shared-mutable-state problems without coordination primitives. [experiment] — could produce a unifying note.

Limitations (our opinion)

What was not tested: This is a position paper with no experiments, benchmarks, or empirical validation. The architectural analogies are argued by analogy to computer hardware, but the authors do not demonstrate that the analogies hold. Specifically:

  • No mapping validation. The three-layer hierarchy (I/O/cache/memory) is asserted to map onto agent systems, but no existing system is analyzed through this lens in enough detail to show the mapping is productive rather than superficial. Our own review of Hindsight and SAGE suggests the mapping is plausible but not inevitable — Hindsight's four-way parallel retrieval doesn't cleanly map to a single "cache layer."

  • Consistency models are named, not proposed. The paper identifies memory consistency as the critical challenge but does not propose any specific consistency model. It stops at "we need something like cache coherence" without addressing why agent memory consistency might require fundamentally different primitives than hardware coherence (which the paper itself acknowledges — semantic conflicts vs. bitwise conflicts).

  • The shared/distributed distinction may be less crisp than claimed. Most practical systems exist between the extremes (the paper acknowledges this), which limits the analytic power of the distinction. A spectrum is useful for orientation but doesn't make predictions the way the paper's framing implies.

  • Missing comparison to distributed systems literature. The paper draws from computer architecture but not from distributed systems (Paxos, Raft, CRDTs, eventual consistency). These are closer analogues to the multi-agent consistency problem than hardware cache coherence, because they handle semantic conflict resolution in heterogeneous, asynchronous environments. The omission weakens the paper's claim to have identified the right architectural lens.

  • No engagement with the cognitive science tradition. Our KB's three-space model (Tulving taxonomy) offers an alternative decomposition that the paper doesn't acknowledge. The two traditions may complement each other, but the paper's silence on cognitive memory models means it doesn't argue for why the hardware lens is better or different.

Write a note titled "Agent memory needs both a content-type axis and a hierarchy axis" connecting to three-space-agent-memory-maps-to-tulving-taxonomy and context-efficiency-is-the-central-design-concern-in-agent-systems — it would argue that neither the cognitive science decomposition (what kind of knowledge) nor the computer architecture decomposition (access speed/capacity/persistence) is sufficient alone, and that a two-axis model predicts which memory content types belong at which hierarchy level, yielding concrete architectural guidance that neither axis provides independently.