The Agent Memory Architecture Wars of October 2026
AI & Machine LearningKnowledge Graphsagent-memoryknowledge-graphsneo4jsurrealdbdatabricksallegrographtencentllm-agentsgraph-databases
Loading…
October 2026 will be remembered as the week agent memory grew up. Between 15 and 20 October, five major products shipped or significantly upgraded — each taking a radically different architectural bet on how an AI agent should store, retrieve, and reason over what it knows. Neo4j released its Context Engine. SurrealDB shipped Agent Memory with a tri-temporal model. Databricks open-sourced MemCurrent. Franz shipped AllegroGraph 9.1 with GraphTalker 2.0. Tencent Hunyuan open-sourced Hy Memory 2.0 — model, framework, and desktop app.
This is not five variations on the same idea. The architectures diverge on the questions that define agent memory: what gets stored, how time is modelled, how conflicts resolve, how forgetting works, and whether the memory layer is a database, a framework, or a trained model. The choices each product makes reveal different theories of what "remembering" means for an agent.
| Product | Vendor | Launch | Core Bet | Storage |
|---|---|---|---|---|
| Context Engine | Neo4j | 20 Oct 2026 | Business ontology graph + GraphRAG retrievers | Neo4j graph database |
| Agent Memory | SurrealDB | 15 Oct 2026 | Tri-temporal model with supersession chains | SurrealDB multi-model DB |
| MemCurrent | Databricks | 20 Oct 2026 | Episodic + derived memory with offline "dreaming" | Databricks platform |
| GraphTalker 2.0 / AllegroGraph 9.1 | Franz | 16 Oct 2026 | Version-controlled context files + neuro-symbolic reasoning | AllegroGraph RDF store |
| Hy Memory 2.0 | Tencent Hunyuan | 15 Oct 2026 | Trained memory writer (30B-A3B MoE) + three memory scenes | Pluggable (ChromaDB, Kuzu, Qdrant, Neo4j) |
Neo4j's Context Engine, launched on 20 October, approaches agent memory as a knowledge-graph problem. The central idea is a six-layer business ontology graph that maps entities, relationships, and their provenance into a structure an agent can traverse at retrieval time. Rather than storing memories as flat text chunks, the Context Engine builds a structured representation that supports GraphRAG-style retrieval — short, long, and reasoning memory tiers, each served by different retrieval strategies.
The architecture is a natural fit for organisations already running Neo4j. The graph database handles the storage layer; the Context Engine adds the ontology mapping, the retrieval pipelines, and the memory-tier orchestration on top. For teams whose data already lives in a graph — customer relationships, supply chains, security graphs — the path to agent memory is an extension of existing infrastructure rather than a greenfield deployment.
The trade-off is complexity. Building and maintaining a six-layer ontology is non-trivial, and the system presumes a graph-centric worldview. Teams whose data is predominantly unstructured may find the ontology construction overhead a barrier compared to a simpler key-value or vector approach.
SurrealDB's Agent Memory, launched on 15 October, takes the most philosophically rigorous position on time of any product in this wave. It models three distinct clocks:
as_of queriesvalid_from and valid_until fieldsThis tri-temporal model solves a problem that most memory systems paper over: the difference between "when we learned something" and "when something was true." A user might say "I became CEO in January 2025" in March — the valid time is January, the known time is March, and the system time is whenever the write landed. Without separating these clocks, point-in-time queries become guesswork.
SurrealDB also distinguishes supersession from forgetting. When a fact changes — Alice's role moves from COO to CEO — the old value is closed with valid_until, not deleted. The supersession chain remains queryable: "what did we believe in February?" is a single as_of query. Forgetting is a separate, explicit verb: soft forget retires a memory from current retrieval but keeps it for audit; hard purge permanently erases it for compliance. A confidence floor (default 0.7) prevents low-confidence extractions from overwriting established high-confidence facts, and cross-provenance clashes — a user statement conflicting with a document — surface as uncertainty records rather than silent overwrites.
The trade-off is richness versus simplicity. Three clocks, supersession chains, confidence floors, and provenance tracking add cognitive overhead for developers who just want "remember what the user said." But for agents operating in regulated or auditable environments — healthcare, finance, legal — the ability to reconstruct belief history is not a luxury; it is a requirement.
Databricks' MemCurrent, also launched on 20 October, takes a different approach entirely. Rather than focusing on temporal modelling or ontology structure, MemCurrent separates memory into episodic memory (what happened in specific interactions) and derived memory (generalised knowledge extracted from those interactions). The distinctive feature is an offline "dreaming" pipeline that processes and consolidates memories when the agent is idle — analogous to how human sleep consolidates experiences into long-term memory.
Databricks reports that MemCurrent improves agent pass rates by 3×, reduces token consumption by 31%, and improves response speed by 26% compared to agents without persistent memory. These numbers come from Databricks' internal benchmarks, so treat them as directional rather than independent. The architecture is tightly integrated with the Databricks platform, which is both its strength (production-grade infrastructure, scalable storage) and its limitation (vendor lock-in).
The "dreaming" concept is the most novel architectural bet in this wave. Most agent memory systems process memories synchronously — extract, store, retrieve, all within the request path. MemCurrent moves consolidation offline, which means memories are not immediately available after an interaction but are richer when they do become available. This trades latency for quality, a bet that aligns with Databricks' batch-processing heritage.
Franz's AllegroGraph 9.1, shipped on 16 October, approaches agent memory from the RDF and symbolic-reasoning tradition. GraphTalker 2.0 is the agentic natural-language interface, and its key innovation is a context management system: per-repository context files that capture ontology, business terminology, domain conventions, and proven query patterns. These context files are version-controlled — modifications preserve snapshots, diffs are visible, and rollback is supported — making the organisation's domain expertise a managed, auditable asset.
GraphTalker positions itself explicitly beyond RAG and GraphRAG. Where RAG retrieves documents and GraphRAG enriches retrieval with relationships, GraphTalker enables agentic investigation: the agent examines schemas, generates and executes SPARQL queries, evaluates results, and iteratively refines its approach. Every query is visible, every tool call is logged, and every answer traces to underlying triples. This is neuro-symbolic AI in production form — the LLM proposes, the graph validates, the system iterates.
The trade-off is that GraphTalker requires an AllegroGraph investment. Teams already running AllegroGraph get a powerful agentic layer; teams without an RDF store face a significant adoption curve. The persistent enterprise memory layer — saved queries, visualisations, and sessions stored in a metagraph — adds long-term value but also architectural complexity.
Tencent Hunyuan's Hy Memory 2.0, open-sourced on 15 October, makes the most unusual architectural bet of the five: a trained model specifically for memory writing. Hy-Memory-30B-A3B is a 30-billion-parameter mixture-of-experts model with 3 billion active parameters, trained via attributed reinforcement learning to decide what to retain, how precisely to represent it, and how new evidence should update persistent state.
The framework organises memory into three scenes:
Hy Memory ranks first among open-source frameworks on four benchmarks: LoCoMo (72.6% chat accuracy), MemoryArena (55.31% working memory), CodeMemoryBench (64.2% QA / 35.6% resolved), and SWE-ContextBench (28.3% resolved). MemHub, the desktop app, unifies conversation history and coding traces from authorised AI tools (Claude Code, Cursor, Codex, OpenCode, Qwen Code) into a single managed memory.
The trade-off is deployment weight. Running a 30B-A3B model as a memory writer requires significant GPU resources, and the three-scene routing adds complexity. But the bet is that memory quality — deciding what to store and how to represent it — is itself a task worth training a model for, rather than leaving it to prompt engineering on a general-purpose LLM.
Three of the five products — Neo4j Context Engine, SurrealDB Agent Memory, and AllegroGraph GraphTalker — are graph-based. This is not coincidence. Agent memory demands three things that graphs handle well:
The two non-graph products — Databricks MemCurrent and Tencent Hy Memory — bet on different strengths: MemCurrent on offline consolidation and platform integration, Hy Memory on a trained memory writer. Both are legitimate bets, but they solve different problems: MemCurrent optimises for throughput and cost, Hy Memory optimises for memory quality.
Choosing among these five depends on three questions:
What is your existing infrastructure? If you run Neo4j, the Context Engine is the path of least resistance. If you run Databricks, MemCurrent integrates natively. If you have an RDF store and SPARQL expertise, AllegroGraph + GraphTalker extends it. If you want a multi-model database with strong temporal semantics, SurrealDB is compelling. If you have GPU capacity and want the highest memory quality, Hy Memory is the bet.
What is your audit requirement? SurrealDB and AllegroGraph lead on auditability — tri-temporal models, supersession chains, and version-controlled context files make belief history reconstructable. Neo4j's Context Engine provides provenance through the graph. MemCurrent and Hy Memory are optimised for agent performance, not regulatory audit.
What is your memory model? Episodic versus semantic, short-term versus long-term, single-agent versus multi-agent — each product makes different assumptions. MemCurrent's dreaming pipeline assumes offline consolidation is acceptable. Hy Memory's three-scene model assumes chat, working, and coding are distinct memory types. SurrealDB's tri-temporal model assumes time matters enough to model explicitly. GraphTalker assumes an enterprise knowledge graph already exists.
The October 2026 wave signals that agent memory has moved from research curiosity to production infrastructure. The five products are not competing for the same workload — they represent five different theories of what remembering means for an agent. The market will likely segment by use case: regulated industries toward SurrealDB and AllegroGraph, platform-native deployments toward Neo4j and Databricks, and quality-sensitive applications toward Hy Memory.
The next battle will be interoperability. An agent that uses Hy Memory for writing, SurrealDB for temporal reasoning, and Neo4j for relationship traversal would be powerful — but no product supports that today. The team that builds the memory abstraction layer — a standard interface over heterogeneous memory backends — will define the next chapter.