Architecting Multi-Agent Transactive Hierarchical Crawlable Memory Without Timestamps

Full report

On this page

Introduction to the Post-Timestamp Agentic Memory Paradigm

As artificial intelligence systems transition from stateless, single-turn conversational interfaces into autonomous, long-horizon workers, the mechanisms by which they store, retrieve, and evaluate historical data have become the primary bottleneck for complex cognitive processing. Early architectures relied on the sheer expansion of the context window—scaling from four thousand to hundreds of thousands of tokens—or deployed simple flat vector databases to retrieve semantically similar text chunks1. However, when deployed in non-stationary environments where multiple agents operate simultaneously, these naive memory systems rapidly degrade4. They suffer from silent contextual misalignment, memory contamination, and an inability to track the evolving truth-value of facts over time6. To sustain coherent, long-term interactions and population-level knowledge sharing, next-generation memory architectures are converging on a synthesis of four distinct structural properties. First, they must be transactive, distributing cognitive load across specialized agents through shared directories of expertise rather than forcing every agent to process raw interaction histories1. Second, they must be hierarchical, decoupling rapid episodic buffering from stable semantic consolidation to protect long-term knowledge from transient noise6. Third, the memory substrate must be crawlable, transforming flat retrieval into an active, multi-hop navigational environment where agents forage for interconnected evidence12. Finally, and most critically, these systems are abandoning chronological timestamps in favor of formal belief revision and conflict-free replicated data types (CRDTs) to manage state, contradictions, and dependency cascades in asynchronous multi-agent networks14. This analysis examines the theoretical foundations, structural architectures, and operational implementations of multi-agent transactive hierarchical crawlable memory systems operating without timestamps. By analyzing frameworks such as CoThinker, Multi-Agent Transactive Memory (MATM), Hierarchical Graph-based Agentic Memory (GAM), Kumiho, and StateFuse, this report maps the transition from simplistic retrieval-augmented generation to fully epistemic, state-tracking agent populations.

Transactive Memory Systems and Cognitive Load Distribution

The performance limits of large language models on complex, multi-faceted tasks are not merely a function of parameter count, but rather a direct analog to human cognitive overload17. According to Cognitive Load Theory (CLT), working memory capacity is strictly bounded. When the demands of a task exceed this capacity, performance precipitously declines17. In artificial systems, this boundary manifests when developers aggressively pack the context window with intricate system instructions, exhaustive tool specifications, and expanding multi-turn histories1. Even when this information technically fits within the physical token limits of massive context windows, models frequently suffer from attention diffusion, exhibiting a phenomenon where they become "lost in the middle" of dense, highly interactive contexts1. In such scenarios, language models exhibit degeneration of thought, hallucination of constraints, sycophantic agreement, or an inability to follow multiple interacting requirements1.

Operationalizing Cognitive Load Theory in LLM Ecosystems

To mitigate this overload, advanced multi-agent architectures operationalize CLT by systematically managing three distinct forms of cognitive load: intrinsic load representing the inherent complexity of the task context, extraneous load derived from raw or poorly formatted information such as raw chat transcripts, and germane load related to schema construction1. The measurement of these loads in artificial systems is achieved using proxies such as Attention Entropy, which measures the sparsity of information integration, and Perplexity, which measures the burden of instruction complexity19. Low Attention Entropy indicates that the model focuses on a sparse set of elements to predict an answer, representing low cognitive load, whereas high entropy indicates uniform attention distribution and subsequent cognitive overload19. The CoThinker framework demonstrates how to resolve this overload by discarding heuristic coordination in favor of a theoretically grounded Transactive Memory System (TMS)1. Human groups effectively manage complex information by developing a TMS—a collective, group-level understanding of "who knows what," how to access distributed expertise, and a collective agreement on the encoded information1. In hybrid environments, such as acute healthcare settings, the inclusion of AI agents within the team's TMS has proven highly catalytic22. Observational studies using the TRAWIS and Co-ACT frameworks reveal that because AI agents are unaffected by human social hierarchies and team dynamics, human team members are more likely to demonstrate "speaking up behavior" and develop novel hypotheses when retrieving unique knowledge from the AI, as they face fewer social hurdles and fear of personal blame22. CoThinker translates this socio-cognitive dynamic into a pure machine architecture through interconnected functional modules1. The Agent Parallel Thinking module addresses intrinsic cognitive load by dynamically assigning thinking styles using an orchestrator based on a general base thinking style inventory, rather than relying on brittle, pre-defined personas that impose extraneous load1. The core TMS module addresses extraneous cognitive load through aggressive context compression1. Rather than forcing every agent to re-read full raw chat transcripts each round, the TMS constructs an evolving structured summary that distills consensus, expertise cues, and open issues into a compact state, functioning as an information bottleneck that arrests token growth1. Finally, the Communication Moderator routes information to cultivate an efficient cognitive small-world network, balancing local cohesion via strong cognitive ties with global integration via weak cognitive ties, before passing the coordinated output to a Synthesizer module for cognitive grounding17.

Population-Level Experience Reuse

While CoThinker addresses coordination within a localized task group, the Multi-Agent Transactive Memory (MATM) framework scales the TMS concept to distributed populations of autonomous agents9. In traditional deployments, intermediate artifacts like action-observation trajectories contain rich procedural knowledge but are discarded after a single use, forcing newly instantiated agents to repeatedly rediscover identical solutions9. MATM introduces a shared repository that functions as a two-sided marketplace for procedural knowledge across open ecosystems25. Producer agents contribute interaction trajectories to the repository, while consumer agents retrieve them to optimize their own execution paths25. Focused on interactive environments such as ALFWorld and WebArena, MATM proves that retrieving agent-generated trajectories improves downstream task performance and reduces total interaction steps without requiring joint parameter training or rigid cooperative protocols9. To optimize this retrieval, MATM employs a Learning-to-Rank pipeline, featuring simple featurization of trajectory information that yields superior retrieval quality, generalizing across diverse tasks and scaling organically as the repository accumulates diverse experiences25.

Hierarchical Memory Topologies for State Isolation

While transactive systems dictate how knowledge is distributed, hierarchical topologies dictate how memory must be structured internally to balance rapid situational perception with the stable retention of absolute knowledge6. The fundamental flaw in unified stream-based memory architectures is their acute vulnerability to transient noise6. When all interactions, regardless of their semantic completeness or reliability, are directly appended to a single active stream, established knowledge is frequently overwritten or structurally isolated6. This continuous exposure causes memory contamination and a severe phenomenon known as semantic drift, where distinct topics are erroneously conflated, irreversibly distorting the agent's thematic consistency6.

Decoupling Encoding from Semantic Consolidation

The Hierarchical Graph-based Agentic Memory (GAM) framework resolves this structural tension by explicitly decoupling memory encoding from consolidation, drawing direct architectural inspiration from biological sleep-dependent memory consolidation6. Rather than maintaining a single unstructured database, GAM separates the memory lifecycle into two physically isolated phases6. Real-time interactions, such as user utterances and immediate system responses, are captured in the active Event Progression Graph6. This local structure models the explicit temporal and causal evolution of the current dialogue flow through atomic interaction units, designed specifically for rapid append operations that minimize encoding latency6. The Event Progression Graph acts as the agent's highly active, yet strictly isolated, working scratchpad6. Updates to the permanent storage layer, the global Topic Associative Network, are strictly suspended during active task execution6. Instead of relying on arbitrary context token limits or periodic chronological timers to trigger memory storage, GAM employs a State-Based Memory Consolidation mechanism that continuously monitors for semantic divergence6. When a topic boundary is crossed, the system initiates a Semantic Consolidation State, processing the buffered episodic details and integrating them into the global network6. Within the Topic Associative Network, nodes represent high-level semantic clusters or abstract themes, while edges capture deep semantic correlations quantified via computationally intensive scoring6. This guarantees that global memory is updated solely with semantically complete units, entirely eliminating cross-topic contamination6. Retrieval is subsequently executed via a Graph-Guided Multi-Factor strategy, which integrates temporal, confidence, and role-based signals into a top-down traversal that successfully bridges the decoupled layers6.

Enterprise-Scale Semantic Trees

At the industrial level, hierarchical structures are vital not only for cognitive stability but for managing computational efficiency, access control, and tenant privacy at scale10. The Hierarchical Long-Term Semantic Memory (HLTM) deployed in LinkedIn's Hiring Assistant illustrates the absolute necessity of tree-structured topologies for massive-scale enterprise deployments10. HLTM organizes behavioral data into a schema-aligned memory tree where higher-level nodes capture broad conceptual patterns, while lower-level leaf nodes store fine-grained, entity-specific information10. This multi-granularity representation supports both generic and highly targeted queries within a unified structure10.

As demonstrated by the performance metrics, HLTM achieves a Pareto-optimal frontier, improving answer correctness by over 5% and retrieval F1 scores by over 10% (outperforming the ReadAgent baseline) while maintaining strict query latencies around three seconds28. Beyond raw speed, the tree topology natively enables Privacy-Preserving Retrieval Scoping10. Because the hierarchy aligns exactly with business scopes, such as specific recruiter seats or isolated projects, retrieval algorithms dynamically restrict traversal to appropriate subtrees10. This ensures strong tenant isolation and transparent provenance—where each memory node is bound to a stable business identifier—without requiring duplicate infrastructure10. Furthermore, lossless incremental ingestion allows the system to update nearline freshness at a negligible computational cost10.

Crawlable Knowledge Graphs and Navigability

The integration of hierarchical structures naturally facilitates the transition from flat vector storage to graph-native environments. For years, retrieval architectures have relied exclusively on semantic similarity, where a query is converted into a dense embedding and matched against the nearest neighbors in a vector database2. This "chunk stuffing" approach is probabilistic and contextually blind; it retrieves isolated fragments that share lexical or semantic proximity but frequently lack logical connectivity or chronological awareness2. When deployed against complex scenarios—such as supply chain logistics where pricing depends on interrelated variables like location, seasonal demand, and service tiers—flat vector retrieval fails entirely13. As AI architecture advances, visibility is shifting rapidly from simple retrievability to active navigability, establishing the knowledge graph as an operational search space rather than a static data asset12.

The Recursive Language Model (RLM-on-KG) Architecture

The RLM-on-KG (Recursive Language Model on Knowledge Graph) architecture epitomizes this shift toward agentic evidence foraging12. Rather than pulling a fixed top-k set of chunks and immediately terminating the search, the system deploys an LLM as an autonomous controller navigating an RDF-encoded mention graph at query time12. This adaptive exploration is formalized as a lightweight Markov Decision Process consisting of three iterative phases12:

1. Entity Discovery: The agent utilizes deterministic lexical tools, such as the entitySearch API, to identify seed nodes within the user's prompt, establishing an initial foothold in the graph and surfacing chunks directly linked to them12.
2. Graph Expansion: Operating within a strict hop budget, the agent traverses explicit schema relationships (e.g., schema:mentions, schema:about), pulling a localized subgraph and expanding into adjacent neighborhoods. This uncovers scattered evidence that single-shot vector searches consistently bypass12.
3. Verification and Extraction: The agent recursively synthesizes the gathered evidence packets, verifies facts across the clusters, and re-ranks the payload before generating a final response supported by highly specific provenance citations (URIs and URLs)12.

Evaluated against a dataset of 150 questions across five classic novels, RLM-on-KG demonstrates a profound shift in interaction12. While traditional RAG struggles with citation behavior, the multi-hop traversal in RLM-on-KG achieves near-perfect citation coverage, though it introduces a novel failure mode termed "overreach," where the richness of the structural data occasionally leads to sophisticated hallucinations if not properly constrained by a grounding judge13. Nonetheless, the ability to trace attribution depth and path efficiency transforms the LLM from a passive consumer of text into an active explorer12.

Ecosystem Generative Engine Optimization (EcoGEO)

This crawlable architecture changes the fundamental nature of how external environments must be structured to interface with AI populations. The Ecosystem Generative Engine Optimization (EcoGEO) framework demonstrates that an agent's evidence-acquisition trajectory is highly sensitive to cross-page connectivity and evidential organization30. Agents do not consume single documents; they issue queries, observe ranked snippets, select links to crawl, and reformulate searches based on intermediate findings30. To achieve AI visibility in this paradigm, structural content engineering is paramount. The TRACE framework proves that optimizing the entry page and the underlying internal link graph dictates the entire downstream response of the LLM30. Consequently, technical SEO must pivot toward machine readability using the CITABLE framework, which emphasizes block-structured content broken into 200-400 word sections, semantic headings, and rigid tables to bypass the complexities of HTML rendering31. Furthermore, organizations must audit robots.txt access to ensure search bots like OAI-SearchBot or PerplexityBot are allowed to traverse content, while implementing Server-Side Rendering (SSR) to ensure dynamic content is visibly indexed in the underlying knowledge graphs powering RAG systems31.

The Fallacy of Timestamps and the Rise of Epistemic State

Despite the profound structural sophistication of hierarchical graphs and recursive foraging, the mechanism historically used to manage memory updates—chronological time—remains deeply flawed when applied to autonomous systems8. Traditional memory systems append every interaction, observation, and document to a continuous log, tagging each entry with a timestamp8. While an event log is correct by definition (an event definitively occurred at a specific time), it fails entirely at state management (determining what is definitively true now)8.

The Retention-Forgetting Dilemma

When agents accumulate chronological experience from world feedback in non-stationary environments, they inevitably trigger a severe operational paradox known as the retention-forgetting dilemma4.

• If the agent retains everything, the context window fills with stale, contradictory rules and insights. A strategy that succeeded on Tuesday may fail catastrophically on Friday, yet both are retrieved via semantic similarity algorithms. The wrong rule fires at the wrong time, producing confident but erroneous outputs, meaning the accumulated experience actively degrades system performance below zero-shot levels4.
• If the agent aggressively discards failed strategies to maintain a clean context, it suffers from catastrophic forgetting. When cyclical environmental conditions recur, the agent possesses no memory of past successes and must repeatedly pay the computational and operational costs of relearning the environment from scratch4.

This dilemma is exacerbated by silent contextual misalignment7. Agents must differentiate between stored memory and operative context—the specific information that actually guides present action7. When an agent acts based on an outdated timestamped memory without exposing that context mismatch to the user, the system fails unpredictably7.

The Implementation of Epistemic Agents

To solve this, memory must be treated not as a chronological append-log, but as a rigorous epistemic state tracker8. An epistemic agent explicitly models belief, confidence, provenance, and volatility as first-class objects rather than as afterthoughts appended to a system prompt32. When querying memory, the agent retrieves a specialized belief object that details the specific strength of the claim, the exact repository commit or document that generated it, its likelihood of having changed (volatility), and whether it is supported or contradicted by other active beliefs32. Crucially, resolving conflicts between two contradictory facts cannot rely merely on a "last-writer-wins" timestamp logic15. A timestamp only indicates when data was recorded, not when it became semantically valid, nor does it resolve which specific agent within a population possesses the superior track record for a specific domain of knowledge32. Therefore, advanced agentic memory discards timestamps entirely as the primary conflict resolution mechanism in favor of formal mathematical logic and distributed systems algorithms14.

Formal Belief Revision (AGM) in Graph Architectures

To manage the non-monotonic lifecycle of knowledge—where facts are continuously added, invalidated, and sometimes reinstated—cutting-edge architectures like Kumiho and Atlas ground their memory systems in the formal AGM (Alchourrón, Gärdenfors, Makinson) belief revision framework14. The AGM framework provides a rigid mathematical foundation for how a logical system must handle belief change, ensuring that when new, contradictory information is introduced, the system transitions to a new, consistent state while mathematically guaranteeing maximal information preservation5.

Implementing Postulates via Structural Primitives

The Kumiho architecture proves that property graph databases, implemented via a dual-store model utilizing Redis for working memory and Neo4j for long-term graph storage, can operationally satisfy the core AGM postulates without relying on timestamps or unpredictable LLM arbitration14. It achieves 100% operational adherence to these formal properties through three specific structural primitives:

• Immutable Revisions: Past beliefs are strictly never overwritten. When a fact changes, a completely new revision node is created in the graph16.
• Mutable Tag Pointers: A pointer indicates the currently accepted truth. Revising a belief consists simply of moving the tag from the old node to the new node, transforming the revision process into a simple pointer operation16.
• Typed Dependency Edges (Depends\_On, Derived\_From): Explicit semantic edges connect upstream facts directly to their downstream conclusions, creating an unshakeable audit trail16.

By utilizing these primitives, the architecture satisfies the fundamental AGM requirements purely through structural constraints16. It satisfies the K2 (Success) postulate because new information is always accepted as the tag pointer moves16. It guarantees K5 (Consistency) because a tag pointer can mathematically only target one node at a time; thus, the system cannot simultaneously believe two contradictory states16. Finally, it satisfies Hansson's base postulates of Relevance and Core-Retainment because changes are localized strictly to the node in question and its direct dependents, meaning the system never arbitrarily deletes unrelated beliefs16. Notably, these systems offer a principled rejection of the AGM Recovery postulate, which suggests that if a belief is contracted and then immediately re-expanded, the original state should be perfectly restored14. Because the architecture utilizes immutable versioning, the historical state is preserved indefinitely, rendering the Recovery postulate operationally irrelevant and theoretically incompatible with strict provenance tracking14.

Cascading Reassessment via Dependency Engines

The true operational power of this non-temporal, formal framework is realized through propagation engines like Ripple, utilized in the local-first Atlas architecture37. In a standard vector database, if the price of a component changes from $89 to $129, the old chunk is updated, but every downstream business plan, strategy document, or email draft that relied on the $89 figure remains silently corrupted because the system lacks structural awareness37. In a Depends\_On graph memory governed by AGM semantics, the update triggers a cascading invalidation protocol37. The system identifies every belief connected via a downstream dependency edge. It does not automatically delete them—which would violate Core-Retainment—but it proactively surfaces them as contradictions requiring reassessment via an adjudication queue37. This converts an intractable cognitive tracking problem into a highly efficient graph traversal operation, ensuring total systemic consistency without ever consulting a timestamp16. The empirical results of this architecture are striking. On the LoCoMo benchmark, Kumiho achieves an overall token-level F1 score of 0.565, including a 97.5% adversarial refusal accuracy, because the memory graph contains no fabricated information, entirely eliminating the basis for hallucinations14. On the LoCoMo-Plus benchmark, testing implicit constraint recall under intentional cue-trigger disconnects, Kumiho reaches 93.3% accuracy, massively outperforming standard baselines such as Gemini 2.5 Pro (45.7%)14. Furthermore, because the architecture is model-decoupled, swapping the underlying inference model from GPT-4o-mini to GPT-4o immediately yields performance gains without altering the memory pipeline, proving that accuracy is a function of the formal architecture, not the model weights14.

Deterministic Conflict Resolution via CRDTs and OpSet

When scaling this non-temporal logic to highly distributed, multi-agent networks operating asynchronously, standard database transactions fail. Different agent replicas will inevitably accumulate conflicting observations across independent branches, retries, and network partitions15. If Agent A learns that a user prefers Python, while an offline Agent B simultaneously deduces a preference for Rust, syncing their memories via chronological timestamps typically results in a silent overwrite, instantly destroying valuable contextual ambiguity8. To solve this concurrency challenge, architectures like StateFuse abandon timestamps and Operational Transformation (OT) algorithms in favor of standard Commutative Replicated Data Types (CRDTs) and OpSet merge semantics15. In classical collaborative environments, OT algorithms rely on a centralized, server-authoritative architecture operating under a three-part state model ([Figure omitted from source export]), representing acknowledged, submitted, and local states40. However, OT demands a centralized server to enforce deterministic conflict resolution, making it unsuitable for peer-to-peer agent networks40. Conversely, CRDTs allow multiple replicas to exchange immutable operations and independently converge on an identical final state without a central server15. This is achieved through mathematically associative, commutative, and idempotent merge operations15. While CRDTs incur a significant memory overhead—frequently storing 34 to 66 MB for a document containing two million characters due to tombstone and vector clock metadata—they provide the essential decentralization required by autonomous swarms40. Crucially, the ordering of operations in a CRDT is dictated by causal vector clocks rather than semantic reading order or unreliable wall-clock timestamps, cementing the detachment from chronological time34.

The StateFuse Contract and Projection Bounding

StateFuse does not invent a new join algebra; rather, it applies the established OpSet substrate directly to agent memory by defining a strict, conflict-aware public contract15.

Through the implementation of the build\_view function, StateFuse derives a task-scoped projection from the materialized memory15. This function returns selected claims when a key is conflict-free, exposes unresolved conflict sets when validation fails, and surfaces contradictions directly to the public decision surface15. Evaluated against a 282-question slice of the MemoryAgentBench dataset, StateFuse proves that forcing multi-valued conflicts up to the agent's decision surface, rather than hiding them behind heuristic sorting algorithms, enables true epistemic tracking15. If a conflict exists, the agent recognizes its own uncertainty and can trigger a tool call to re-verify the ground truth, effectively utilizing structural ambiguity to enhance system safety and reliability32.

Conclusion

The evolution of agentic memory represents a fundamental architectural shift from passive data storage to active, structural epistemology. Standard flat vector retrieval, heavily reliant on chronological logging and semantic similarity, is entirely insufficient for the complex, non-stationary realities of autonomous multi-agent populations. By analyzing the convergence of Transactive Memory Systems, frameworks such as CoThinker and MATM demonstrate how to efficiently distribute intrinsic and extraneous cognitive load across specialized nodes, treating procedural experience as a reusable, population-level commodity. Hierarchical topologies such as HLTM and GAM protect this shared intelligence, structurally isolating volatile real-time episodic perception from stable, global semantic networks to prevent semantic drift. When constructed as a crawlable substrate, as evidenced by RLM-on-KG and EcoGEO, this memory ceases to be a mere database and becomes an expansive, navigable environment where agents forage across structured relations to build robust, verifiable conclusions. Crucially, the integrity of this multi-agent ecosystem requires the total abandonment of chronological timestamps as a resolution mechanism. Through the rigorous integration of formal AGM belief revision in systems like Kumiho and Atlas, and the application of CRDT OpSet semantics in StateFuse, memory conflict is resolved mathematically through immutable versioning, strict dependency tracking, and bounded projection. This post-timestamp paradigm ensures that agent populations operate within a perfectly auditable, logically consistent universe, fully equipped to handle the cascading complexities and inherent contradictions of real-world deployment.

Works cited

1. United Minds or Isolated Agents? Exploring Coordination of LLMs under Cognitive Load Theory \- arXiv, https://arxiv.org/html/2506.06843v3
2. Agent memory: the missing layer in enterprise AI systems \- Dataiku, https://www.dataiku.com/blog/agent-memory
3. Graph-Native Cognitive Memory for AI Agents: Formal Belief Revision Semantics for Versioned Memory Architectures \- arXiv, https://arxiv.org/pdf/2603.17244
4. Closing the Feedback Loop: From Experience Extraction to Insight Governance in Verbal Reinforcement Learning \- arXiv, https://arxiv.org/html/2606.17591v1
5. From Experience Extraction to Insight Governance in Verbal Reinforcement Learning \- arXiv, https://arxiv.org/pdf/2606.17591
6. GAM: Hierarchical Graph-based Agentic Memory for LLM Agents \- ACL Anthology, https://aclanthology.org/2026.acl-long.1600.pdf
7. Operative Contexts: Belief Revision and Memory in Agentic AI \- OpenReview, https://openreview.net/forum?id=2fuMt0utI3
8. Memory is a trajectory, not a record. | moltbook, https://www.moltbook.com/post/a6104ac6-f2da-465b-a3f3-0fcd73bfbb27
9. Multi-Agent Transactive Memory \- arXiv, https://arxiv.org/html/2606.19911v1
10. Hierarchical Long-Term Semantic Memory for LinkedIn's Hiring Agent \- arXiv, https://arxiv.org/html/2604.26197v1
11. GAM: Hierarchical Graph-based Agentic Memory for LLM Agents \- ACL Anthology, https://aclanthology.org/2026.acl-long.1600/
12. Knowledge Graphs as Search Spaces: How AI Agents Navigate, Not Just Retrieve \- WordLift, https://wordlift.io/blog/en/knowledge-graph-search-space-ai-navigation/
13. RLM-on-KG: Recursive Language Models and the Future of SEO \- WordLift Blog, https://wordlift.io/blog/en/recursive-language-models-on-kg/
14. Graph-Native Cognitive Memory for AI Agents: Formal Belief Revision Semantics for Versioned Memory Architectures \- arXiv, https://arxiv.org/html/2603.17244v1
15. StateFuse: Deterministic Conflict-Preserving Memory for Multi-Agent Systems \- arXiv, https://arxiv.org/html/2607.05844v1
16. Why Agent Memory Needs a Graph: Lessons from the Kumiho Architecture | Ranjan Kumar, https://ranjankumar.in/why-agent-memory-needs-a-graph-lessons-from-the-kumiho-architecture
17. United Minds or Isolated Agents? Exploring Coordination of LLMs under Cognitive Load Theory \- arXiv, https://arxiv.org/html/2506.06843v1
18. United Minds or Isolated Agents? Exploring Coordination of LLMs under Cognitive Load Theory \- OpenReview, https://openreview.net/pdf/6dc0e629dd4f830eb6423ef35ecd30ac572055b5.pdf
19. United Minds or Isolated Agents? Exploring Coordination of LLMs under Cognitive Load Theory | OpenReview, https://openreview.net/forum?id=9JxOVBdwNf
20. United Minds or Isolated Agents? Exploring Coordination of LLMs under Cognitive Load Theory \- arXiv, https://arxiv.org/html/2506.06843v2
21. Developments of Transactive Memory Systems and Collective Mind in Virtual Teams, https://www.researchgate.net/publication/235252810\_Developments\_of\_Transactive\_Memory\_Systems\_and\_Collective\_Mind\_in\_Virtual\_Teams
22. Human-AI teaming: leveraging transactive memory and speaking up for enhanced team effectiveness \- PMC, https://pmc.ncbi.nlm.nih.gov/articles/PMC10436524/
23. Human-AI teaming: leveraging transactive memory and speaking up for enhanced team effectiveness \- Frontiers, https://www.frontiersin.org/journals/psychology/articles/10.3389/fpsyg.2023.1208019/full
24. (PDF) United Minds or Isolated Agents? Exploring Coordination of LLMs under Cognitive Load Theory \- ResearchGate, https://www.researchgate.net/publication/392530283\_United\_Minds\_or\_Isolated\_Agents\_Exploring\_Coordination\_of\_LLMs\_under\_Cognitive\_Load\_Theory
25. Multi-Agent Transactive Memory \- arXiv, https://arxiv.org/pdf/2606.19911
26. GAM: Hierarchical Graph-based Agentic Memory for LLM Agents \- arXiv, https://arxiv.org/html/2604.12285v1
27. Graph-based Agent Memory: Taxonomy, Techniques, and Applications \- arXiv, https://arxiv.org/html/2602.05665v1
28. Hierarchical Long-Term Semantic Memory for LinkedIn's Hiring Agent \- arXiv, https://arxiv.org/html/2604.26197v2
29. Hierarchical Long-Term Semantic Memory for LinkedIn's Hiring Agent \- arXiv, https://arxiv.org/pdf/2604.26197
30. EcoGEO: Trajectory-Aware Evidence Ecosystems for Web-Enabled LLM Search Agents \- arXiv, https://arxiv.org/html/2605.12887v1
31. Crawlability & Indexing for AI Search: Ensuring LLMs Can Access and Understand Your Content | Discovered Labs, https://discoveredlabs.com/blog/crawlability-indexing-for-ai-search-ensuring-llms-can-access-and-understand-your-content
32. Epistemic Agents and Epistemic Memory: Teaching AI Systems to Know What They Know | by NJ Raman | Jul, 2026 | Medium, https://medium.com/@nraman.n6/epistemic-agents-and-epistemic-memory-teaching-ai-systems-to-know-what-they-know-df4a80fd13fb
33. Temporal Knowledge-Graph Memory in a Partially Observable Environment \- arXiv, https://arxiv.org/html/2408.05861v4
34. Ep1: The CRDT Ordering Bug — Skill to Binary Series \- Brian Takita, https://briantakita.me/posts/skill-to-binary-ep1-crdt-ordering/
35. AI Agent Memory Architectures for Multi-Agent Systems | Zylos Research, https://zylos.ai/research/2026-03-09-multi-agent-memory-architectures-shared-isolated-hierarchical
36. \[2603.17244\] Graph-Native Cognitive Memory for AI Agents: Formal Belief Revision Semantics for Versioned Memory Architectures \- arXiv, https://arxiv.org/abs/2603.17244
37. RichSchefren/atlas: Open-source local-first cognitive memory. AGM-compliant belief revision (49/49 postulates). When a fact changes, downstream beliefs are automatically re-evaluated, not just flagged. · GitHub, https://github.com/RichSchefren/atlas
38. Kumiho AI Cognitive Memory — Graph-Native Agent Memory | 93% Recall Accuracy, https://kumiho.io/use-cases/ai-cognitive-memory
39. StateFuse: Deterministic Conflict-Preserving Memory for Multi-Agent Systems \- arXiv, https://arxiv.org/pdf/2607.05844
40. OT vs CRDT in 2026: Choosing the Right Algorithm for Multiplayer Apps \- Taskade, https://www.taskade.com/blog/ot-vs-crdt
41. nZiben/statefuse \- GitHub, https://github.com/nZiben/statefuse