Timestamp-Free Multi-Agent Transactive Memory Systems

Full report

On this page

Executive summary

A multi-agent transactive memory system can be understood as a distributed “who-knows-what” mechanism: each agent does not need to store everything, but the collective needs reliable ways to encode information, remember where expertise lives, retrieve the right memory, and coordinate updates. In the classical literature, transactive memory is defined as a set of individual memory systems plus the communication that connects them; later work operationalized it with three dimensions that are still highly relevant for AI systems: specialization, credibility, and coordination. In modern agent architectures, those dimensions map naturally to role assignment, confidence and provenance tracking, and synchronization policies across local and shared stores.

If the design goal is to prevent temporal metadata from affecting relevance, timestamps and explicit dates should not be fed into the default ranking signal. That is not merely a stylistic choice. Recent work on LLM-based reranking shows that injecting publication dates can systematically push “newer-looking” content upward even when semantic relevance is unchanged, shifting ranking distributions and reversing pairwise preferences. Adjacent literature on recommendation and data leakage shows the same pattern more broadly: recency cues can become confounders, and temporal leakage can inflate offline performance while harming deployment validity.

The strongest timestamp-free alternative is not a single signal but a multi-signal relevance stack. In practice, the most defensible design combines lexical and dense semantic similarity for content fit, interaction-frequency and downstream-utility signals for practical usefulness, calibrated confidence and provenance for trust, graph centrality for structural importance, novelty detection to suppress redundancy, and semantic-drift penalties to demote memories that no longer match the current concept landscape. Recent agent-memory systems and benchmarks increasingly converge on this view: memory quality depends not only on storing and retrieving facts, but also on updating, forgetting, reconciling conflicts, and scaling abstraction without losing specificity.

For long-term maintenance, the most robust timestamp-free pattern is a content-addressed memory graph with semantic supersession rules, duplicate compaction, probe-based validation, and probabilistic or utility-aware forgetting. For synchronization, use anti-entropy gossip plus CRDT-style merge semantics, but prefer timestamp-free variants such as observed-remove tags, content hashes, or Merkle-DAG predecessor links over last-write-wins timestamp schemes. For evaluation, standard IR metrics remain necessary, but they are insufficient: you also want stale-answer penalties, contradiction rate, inter-agent coherence, storage and communication cost, retrieval latency, robustness to concept drift, and resistance to memory poisoning.

Because scale, agent heterogeneity, and application domain were left unspecified, the report below favors architectures that degrade gracefully across settings: modular local memories, a shared semantic index, hashed synchronization primitives, and learned prioritization policies that can be swapped out without changing the storage core. That is the safest default when system size, failure model, and domain drift are unknown.

Foundations of transactive memory in multi-agent systems

Wegner’s original formulation describes a transactive memory system as a set of individual memory systems together with the communication that links them. The core idea is that an intelligent collective does not only remember facts; it remembers locations of facts, labels for those facts, and pathways for retrieval through other members or external stores. That is why the classical theory puts so much emphasis on metamemory and location information. Groups become effective not by redundantly copying everything into every member, but by building reliable routes from a cue to the agent or external store that can answer it.

Later organizational work made the theory more operational. Argote and Ren describe transactive memory as a shared system for collectively encoding, storing, and retrieving information across domains, in plain terms “knowledge of who knows what.” They also summarize the most widely used indicators from Lewis and related work: specialization, task credibility, and task coordination. Those three indicators remain the cleanest abstraction for engineering multi-agent memory today. Specialization says who is responsible for which memory domain; credibility says how much the rest of the system should trust that source; coordination says how smoothly agents can pass cues, tasks, and partial results among themselves.

This classical framing aligns surprisingly well with current agent systems. A-Mem structures interactions as linked notes and dynamically organizes memory; AriGraph separates semantic and episodic memory in a graph world model; G-Memory stores insight, query, and interaction graphs to capture collaboration trajectories; and recent joint-optimization work models memory systems as heterogeneous multi-agent pipelines with extraction, profiling, and retrieval agents. Put differently, current agent-memory research is re-implementing specialization, credibility, and coordination in machine form.

A second lesson from the TMS literature is that transactive memory helps not only in stable conditions but also under change. Argote and Ren note simulation and computational work showing that transactive memory is valuable when problems change and knowledge becomes obsolete, and that it improves adaptation to novel tasks. That matters here because a timestamp-free design is, at bottom, an attempt to let semantic adaptation outrank crude chronological heuristics.

The central engineering translation is therefore:

• Specialization → agent roles, namespace ownership, skill routing, or domain-specific stores.
• Credibility → confidence calibration, provenance weighting, validator consensus, and access policy.
• Coordination → merge semantics, anti-entropy, retrieval delegation, and workflow consistency.

That translation also predicts a classic failure mode: turnover or agent churn. Organizational TMS research shows that effectiveness can be negatively affected when members leave, because knowledge is cospecialized across people rather than fully embodied in routines. Analogously, multi-agent AI systems that encode expertise too strongly in a single agent or module become brittle under agent replacement, retraining, or outage.

flowchart LR
    U[User query] --> O[Orchestrator]
    O --> R1[Domain Agent A]
    O --> R2[Domain Agent B]
    O --> R3[Domain Agent C]

    R1 <--> L1[Local episodic store]
    R2 <--> L2[Local semantic store]
    R3 <--> L3[Local procedural store]

    R1 --> S[Shared transactive memory graph]
    R2 --> S
    R3 --> S

    S --> P[Provenance and confidence layer]
    P --> V[Validation and pruning]
    V --> S

    S --> O
    O --> A[Final response]

The architecture above is a synthesis of the TMS literature and recent agent-memory systems: local specialization, a shared memory index, and a governance layer that handles confidence, provenance, and pruning rather than assuming that all stored items are equally trustworthy or equally retrievable.

Why timestamps distort relevance

Explicit timestamps and dates are attractive because they are easy to sort on, but they introduce a powerful spurious feature: “newer-looking” often becomes a shortcut for “more relevant.” Recent work on LLM reranking makes that concrete. Fang and colleagues injected artificial publication dates into passages in TREC Deep Learning collections and found that across seven models, fresh-looking passages were consistently promoted; the mean publication year of the Top-10 could shift forward by as much as 4.78 years, and pairwise preferences between equally relevant passages could reverse by around 25 percent on average after date injection. That is direct evidence that dates can bias relevance independent of semantics.

The same phenomenon appears outside LLM reranking. In recommendation, Chen and colleagues characterize a recency bias in job recommendation and show that correcting for it with unbiased learning-to-rank improves quality over strong baselines. In other words, raw recency can dominate the learned ranking signal even when it is not the real target of the task.

A closely related systems problem is temporal leakage. Recent work on temporal data leakage shows that features unavailable at prediction time, including future information, can make offline accuracy look far better than what a deployed system can achieve. A recent taxonomy paper argues that using chronologically later builds in software prediction yields scientifically invalid deployment estimates, and a broader empirical study identifies temporal leakage as a standard failure mode in ML evaluation. For memory systems, explicit dates can create a softer but analogous problem: evaluation starts rewarding chronology-sensitive shortcuts rather than durable semantic relevance.

That does not mean time is never useful. Benchmarks such as LongMemEval explicitly test temporal reasoning and knowledge updates, which are legitimate capabilities. The design implication is subtler: if the query is intrinsically temporal—“what changed,” “what is the latest,” “what was valid before”—then time should be handled in a separate reasoning stage or by an explicit temporal tool. But for generic relevance ranking, dates should not silently dominate retrieval. LongMemEval itself highlights knowledge updates as a distinct challenge, which supports keeping temporal reasoning explicit rather than smuggling it into the base relevance score.

Alternative relevance signals

The most practical replacement is a composite score that excludes explicit time metadata:

\[ \text{Score}(m,q)= w_s S_{\text{semantic}}+ w_f S_{\text{frequency}}+ w_u S_{\text{utility}}+ w_c S_{\text{confidence}}+ w_p S_{\text{provenance}}+ w_g S_{\text{graph}}+ w_n S_{\text{novelty}} - w_d S_{\text{drift}} - w_r S_{\text{redundancy}} \]

The literature supports almost every term in that expression, even if no single paper bundles them all together. Lexical and dense retrieval cover content fit; rank fusion combines heterogeneous views; provenance supports trust judgments; graph metrics capture structural importance; MMR-style novelty suppresses redundancy; uncertainty-aware retrieval calibrates confidence; and recent memory-agent work increasingly learns retention or retrieval utility directly from downstream performance.

The practical takeaway is that freshness should become semantic, behavioral, and structural, not chronological. A memory is “current” when it still predicts the world well, is corroborated by trusted sources, survives contradiction checks, and continues to improve task performance—not merely because its metadata says it was written recently. That view is closer to concept-drift literature than to timestamp sorting.

Maintaining long-term memory without dates

Keeping memory “up to date” without dates sounds paradoxical, but the better framing is: keep memory consistent with current semantics and current utility. Recent agent-memory benchmarks increasingly emphasize that storing information is not enough; the hard part is handling updates, contradictions, and invalidated memories. LongMemEval includes knowledge updates as a first-class evaluation target, MemoryAgentBench includes selective forgetting, and Memora introduces FAMA specifically to penalize reliance on obsolete or invalidated memory.

Memory lifecycle without explicit dates

flowchart TD
    I[Incoming interaction or observation]
    I --> X[Extract candidate memory units]
    X --> D[Deduplicate and semantic-diff]
    D --> C[Confidence and provenance scoring]
    C --> E[Write to local or shared store]
    E --> R[Retrieve for future tasks]
    R --> F[Measure task utility and contradictions]
    F --> P[Probe validation and drift detection]
    P --> K[Keep, merge, supersede, or forget]
    K --> E

This lifecycle reflects a broad consensus in recent work: memory systems need explicit indexing, retrieval, reading, updating, and forgetting stages, not a single append-only buffer. LongMemEval formalizes indexing, retrieval, and reading; MemoryAgentBench adds selective forgetting; and newer systems such as Memora and G-Memory add internal structure so that abstraction and cross-memory links can support efficient consolidation instead of naïve accumulation.

Maintenance methods

A strong timestamp-free pattern for supersession is to represent updates as a semantic conflict graph rather than as a chronological chain. Two facts conflict if they share a subject-predicate slot or equivalent schema role, exceed a contradiction threshold under a validator or entailment model, and come from comparable provenance scopes. The newer fact is not accepted because it is newer; it is accepted because it better matches current probe performance, has stronger provenance, or wins consensus among validators. That is the core conceptual move away from time.

Content-addressable storage is particularly valuable here. Merkle-CRDT work shows that content hashes and DAG links can serve as the transport and persistence layer for replicated state. This gives you immutable object identity, efficient deduplication, and a natural place to store provenance and supersession edges without forcing last-write-wins timestamp semantics.

One caveat is deletion. CRDT literature repeatedly notes tombstone growth and the need for garbage collection. In a timestamp-free design, deletion should usually be logical before physical: first mark content as superseded or retired by semantic criteria, then physically compact it once replicas have converged sufficiently. That reduces resurrection and merge anomalies while keeping the foreground path cheap.

Synchronization and coordination without timestamp metadata

For synchronization, the simplest robust baseline is epidemic anti-entropy. Demers and colleagues showed long ago that replicas can periodically choose peers and exchange state to drive eventual consistency. That basic idea still matters because it does not require central coordination or trusted global clocks. For large systems, partial-view membership protocols such as HyParView preserve gossip scalability without requiring every node to know the full population.

On top of anti-entropy, CRDTs provide merge rules that guarantee convergence when replicas have received the same updates. The key advantage is that merging is defined semantically, not temporally. State-based and delta-state CRDTs let replicas exchange either full joined state or smaller deltas, while still converging deterministically. That makes them a natural fit for shared agent memory where low coordination overhead matters.

The crucial design choice for a timestamp-free system is to avoid last-write-wins registers keyed by wall-clock or explicit date metadata. Those are precisely what smuggle chronology into conflict resolution. Instead, the main alternatives are:

• Pure semilattice merge, where conflicts collapse via associative, commutative, idempotent join.
• Observed-remove tags, where adds carry unique tags and removes act on observed tags rather than timestamp order.
• Content-hash predecessor DAGs, where causal structure is represented by parent hashes or Merkle links rather than explicit vector-clock metadata.
• Quorum or validator-based retirement, where conflicting semantic entries are pruned through weighted agreement, not by whichever write claims later time.

Observed-remove sets are a concrete example. In OR-Set semantics, concurrent add and remove are handled using unique tags, and the add wins if the remove did not observe that tag. That gives causality-sensitive behavior without requiring timestamp comparison at merge time.

Merkle-CRDTs push the idea further. Their main contribution is to replace traditional clock-heavy synchronization with content-addressed DAG structures, using Merkle-style causal objects to support per-object causal consistency under weak messaging guarantees and many replicas. For a memory system, that means an agent can sync by exchanging heads and missing hashes, not by comparing dates.

sequenceDiagram
    participant A as Agent A
    participant B as Agent B
    participant G as Gossip peer set
    participant M as Shared Merkle memory

    A->>M: propose memory delta with content hash
    M-->>A: ack local join
    A->>G: advertise new head hash
    G->>B: propagate head hash
    B->>M: request missing ancestors/deltas
    M-->>B: transmit missing objects
    B->>B: join local state, run semantic conflict checks
    B->>M: publish merged head

That flow is especially attractive when timestamp metadata is forbidden from affecting relevance. Sync uses hashes and join rules; retrieval uses semantic and utility signals; contradiction resolution uses validation and provenance. Time never enters the default path unless the user explicitly asks a temporal question.

Recent multi-agent memory papers also show that coordination is not just about state merge. G-Memory models interaction trajectories in a three-tier hierarchy, and CoMAM treats extraction, profiling, and retrieval as distinct agents trained jointly with adaptive credit assignment. The lesson is that synchronization protocol and task-level coordination should be decoupled but compatible: storage converges through merge semantics while agent policies learn who should write, summarize, validate, and retrieve.

Evaluation and implementation patterns

Memory evaluation is now moving beyond “did the system retrieve something correct?” LongMemEval evaluates information extraction, multi-session reasoning, temporal reasoning, knowledge updates, and abstention, and reports a substantial accuracy drop for sustained interactions. MemoryAgentBench defines four competencies—accurate retrieval, test-time learning, long-range understanding, and selective forgetting—and argues that existing methods still fail to master all four. Memora adds FAMA to penalize reliance on obsolete or invalidated memories. Together, these benchmarks suggest that timestamp-free memory should be judged on update handling and forgetting quality just as much as recall quality.

LoCoMo remains valuable because it pressures models on very long conversations, event structure, and multimodal grounding. Memora is particularly relevant because it explicitly targets evolving multi-session memory and evaluates remembering, reasoning, and recommending over weeks-to-months trajectories. That makes it an excellent substrate for timestamp-free experiments: you can remove or shuffle dates and see whether semantic and utility signals still preserve performance.

Recommended metric suite

A practical implementation pattern

The most reusable implementation pattern is a four-layer stack:

1. Local episodic layer for each agent, storing raw observations, task traces, and tool outputs.
2. Shared semantic layer that stores distilled facts, profiles, procedures, and graph links.
3. Governance layer that attaches provenance, confidence, access policy, and validator results.
4. Synchronization layer built on anti-entropy plus CRDT or Merkle-DAG merge rules.

A memory write should therefore be treated as a pipeline, not a single insert. First extract candidate units. Then deduplicate via semantic diff. Then assign provenance, confidence, and utility priors. Then decide whether the write belongs only in a local store, in the shared store, or in both. Finally, publish a small delta for anti-entropy sync. Retrieval should reverse the process: candidates by content, rerank by utility/provenance/graph support, then run a contradiction filter before use. That mirrors the indexing–retrieval–reading split in LongMemEval and the structured abstraction in Memora.

Pseudocode

The following pseudocode is a timestamp-free reference design.

def write_memory(event, agent_id, local_store, shared_store, validator):
    candidates = extract_memory_units(event)

    for m in candidates:
        m.embedding = embed(m.content)
        m.provenance = build_provenance(event, agent_id)
        m.confidence = estimate_confidence(m, event)
        m.utility_prior = estimate_initial_utility(m)

        near_dupes = shared_store.search_by_embedding(m.embedding, top_k=10)
        merged = semantic_merge_if_equivalent(m, near_dupes, validator)

        if merged is not None:
            shared_store.upsert(merged)
        elif should_share(m):
            shared_store.put(content_hash(m), m)
        else:
            local_store.put(content_hash(m), m)


def retrieve_memory(query, agent_id, local_store, shared_store, validator):
    lexical = shared_store.bm25(query, k=50)
    semantic = shared_store.vector_search(query, k=50)
    local = local_store.vector_search(query, k=25)

    candidates = fuse_rankings([lexical, semantic, local])  # e.g., RRF

    rescored = []
    for m in candidates:
        score = (
            semantic_relevance(query, m)
            + usage_frequency_score(m)
            + utility_score(m)
            + confidence_score(m)
            + provenance_score(m)
            + graph_centrality_score(m)
            + novelty_bonus(m, rescored)
            - redundancy_penalty(m, rescored)
            - semantic_drift_penalty(m, shared_store.current_concepts())
        )
        if not validator.contradicted(m, query):
            rescored.append((m, score))

    return top_k(sorted(rescored, key=lambda x: x[1], reverse=True), k=12)


def sync_replica(replica, peer):
    local_heads = replica.head_hashes()
    peer_heads = peer.head_hashes()

    missing_from_peer = diff_hash_frontiers(local_heads, peer_heads)
    missing_from_local = diff_hash_frontiers(peer_heads, local_heads)

    peer.send(replica, missing_from_peer)
    replica.send(peer, missing_from_local)

    replica.join_received_objects()
    replica.run_background_gc()
    replica.run_probe_validation()

The design ideas behind this pattern are well supported individually even if the exact combination is a synthesis: multi-signal retrieval from IR, structured memory from recent agent systems, forgetting from modern memory benchmarks, and convergence from gossip plus CRDT/Merkle replication.

Illustrative example charts

The chart below is illustrative, not copied from a specific study. It shows the kind of trade-off curve you would want to plot in experiments: utility-aware timestamp-free memory often improves stale-memory resistance before it saturates on storage budget.

xychart-beta
    title "Illustrative storage budget versus forgetting-aware accuracy"
    x-axis "Relative storage budget" ["very low", "low", "medium", "high", "very high"]
    y-axis "FAMA or validity-aware score" 0 --> 100
    line [42, 58, 74, 79, 80]

A second useful chart is robustness under semantic drift. The point is not that timestamp-free systems always win, but that they should degrade more gracefully than date-biased baselines when explicit dates are removed, shuffled, or adversarially injected.

xychart-beta
    title "Illustrative drift robustness"
    x-axis "Drift severity" ["none", "mild", "moderate", "high"]
    y-axis "Task accuracy" 0 --> 100
    line [83, 78, 71, 63]

Trade-offs, failure modes, security, and research agenda

The central trade-off is simple: replacing timestamps with richer signals usually improves semantic validity, but it also adds model, storage, and coordination complexity. A pure timestamp sort is cheap and brittle. A multi-signal policy is more robust but needs embeddings, validators, confidence estimates, and richer metadata. Memora, G-Memory, and recent RL-based memory work all move toward more structure and more learned control for exactly that reason.

A second trade-off is abstraction versus specificity. Memora is explicit that abstraction is necessary for scaling memory but can hide the fine-grained details needed for reasoning; its contribution is to structurally balance the two. This is especially important in timestamp-free systems because if you remove the convenience of chronological shortcuts, you need better structure to preserve the “right” details.

A third trade-off is stability versus adaptability. Frequency and centrality signals favor durable, widely used memories, which helps coordination but risks preserving stale hubs. Drift-sensitive and novelty-sensitive policies adapt faster, but can overreact and thrash. That is where probe validation and provenance weighting help: they stabilize update decisions without reverting to raw chronology.

Failure modes

Common failure modes in timestamp-free TMS designs include semantic aliasing, duplicate inflation, validator bias, specialization collapse, and stale-hub dominance. Semantic aliasing happens when two memories are near each other in embedding space but differ on a critical slot or quantifier. Duplicate inflation happens when paraphrases escape merging and later swamp retrieval. Specialization collapse happens when one strong agent or namespace becomes the default source for too many domains, reintroducing a single point of failure. Stale-hub dominance happens when centrality or usage counters keep an old memory highly ranked even after the world has changed. The TMS literature’s emphasis on specialization and coordination, plus modern drift and forgetting benchmarks, are directly relevant because they show that collective memory fails as often through routing and update errors as through missing facts.

Security and privacy

Shared memory is now a meaningful attack surface. AgentPoison introduced long-term memory or RAG poisoning as a backdoor vector against agents, and more recent work systematizes memory poisoning attacks, showing that existing prompt-injection defenses do not fully cover them. In practical terms, a timestamp-free system does not automatically become safer just because it avoids time metadata; if anything, richer shared memory increases the attack surface unless every write carries provenance, validation status, and scope constraints.

The privacy problem is equally serious in multi-user settings. Collaborative Memory proposes private and shared tiers with dynamic access control, provenance attributes, and policy-based views specifically because cross-user memory sharing is otherwise too risky. For production systems, that suggests a strong rule: never let a relevance ranker see a memory item that the current agent–user context is not already authorized to inspect. Access control must happen before ranking, not after.

Provenance is also a core defense mechanism, not just an audit nicety. The W3C PROV model explicitly frames provenance as information that supports judgments about quality, reliability, and trustworthiness. In a multi-agent memory system, provenance should therefore feed both human audit and machine reranking: source type, toolchain, validator identity, and transformation lineage are legitimate relevance features because they speak to whether a memory should be trusted.

Finally, embedding-drift detection has emerging security value. Recent work on zero-shot embedding drift detection uses changes in embedding space to detect prompt injections. Even though that work is about prompt injection rather than generic memory staleness, the same signal family is promising for detecting suspicious memory writes that are semantically far from a store’s normal distribution or abruptly reshape the neighborhood around sensitive concepts.

Open research questions and recommended experiments

The most important open question is whether timestamp-free freshness can match or exceed time-aware retrieval on tasks that involve evolving facts but do not explicitly ask for chronology. Current benchmarks show that update handling and selective forgetting remain weak across methods, but they do not yet isolate how much of present-day performance comes from semantic competence versus date shortcuts.

A second open question is where to place learning. Recent work spreads intelligence across the stack: A-Mem organizes memory agentically, MEM1 uses reinforcement learning for long-horizon memory management, CoMAM jointly trains heterogeneous memory agents, and selective shared-memory work learns what cross-team information is worth sharing. The unresolved issue is whether retrieval, retention, abstraction, and synchronization should be trained jointly or kept modular for interpretability and safety.

A third open question is adversarial robustness under shared-state reuse. Current poisoning papers show that persistent memory can be compromised through a small number of crafted entries, and current defenses remain incomplete. The missing research is not merely defensive filtering but policy-aware memory semantics: how should merge, supersession, and access logic change under adversarial assumptions?

The following experiments would be especially informative:

These experiments would complement today’s benchmarks rather than replace them. LoCoMo stresses very long conversational memory; LongMemEval stresses updates and abstention; MemoryAgentBench stresses selective forgetting; Memora stresses evolving multi-session personalization. What is still missing is a benchmark that explicitly separates semantic freshness from timestamp freshness.

The strongest recommendation from the current evidence is therefore not “ban time everywhere.” It is: ban time from default relevance, surface it only when the task is explicitly temporal, and replace it with a governed combination of semantic fit, utility, provenance, confidence, drift, and coordination-aware structure. That design choice is theoretically aligned with transactive memory, empirically motivated by recency-bias research, and operationally compatible with modern multi-agent memory systems.