How agent memory, context engineering, and knowledge graphs are converging in 2026, and where Living Memory and Alexandria fit.
Agents with skills and tool access can do remarkable work. But without shared memory, every session starts from zero. No lessons from last time. No precedent. No pattern recognition across sessions or across agents.
Memory is the multiplier; agency is the force. The question is: what kind of memory, and how does it compound?
Each step addresses a limitation of the last. RAG gave agents knowledge. Agentic RAG gave them judgment about retrieval. AI Memory gives them the ability to learn, remember, and forget.
The industry consensus in 2026: the bottleneck isn't the model, it's the context the model receives. "Context engineering" is the discipline of assembling the right knowledge, at the right moment, at the right depth, for the right agent.
This is more than prompt design. It spans retrieval, filtering, scoping, progressive disclosure, token budgets, and deciding what to exclude. The model is only as good as what you put in the window.
Our entire architecture is a context engineering system. getContext, retrieval filters, workflow-scoped precedent, token budgets, progressive disclosure: these are all context engineering.
Every sophisticated RAG pattern either adds graph structure (Graph RAG, Hybrid RAG) or adds agentic reasoning to compensate for search limitations (Adaptive RAG, Agentic RAG). Each escalation is a workaround for something curated graph traversal handles natively.
Graphs provide two things embeddings can't: typed relationships (decisions link to assumptions, assumptions link to evidence) and structural discovery (the third hop takes you to territory you didn't aim for). Search can't escape the query neighborhood. Graphs can.
| Vector search | Knowledge graph | |
|---|---|---|
| Finds | Text similar to query | Entities connected to understanding |
| Discovery | Locked to query neighborhood | Multi-hop traversal across topics |
| Relationships | Implicit (cosine distance) | Explicit, typed, directional |
| Maintenance | Re-embed on change | Update claims, prune, challenge |
| Gives the agent | Related text | Reasoning structure |
Foundation Capital calls context graphs "AI's trillion-dollar opportunity." The argument: systems of record capture what happened. Context graphs capture why, who, when, and what precedent. Decision traces, not just state changes.
The gap isn't missing data. It's missing decision traces. Agents run into the same ambiguity humans resolve with judgment and organizational memory. But the inputs to those judgments aren't stored as durable artifacts. Context graphs make them durable, queryable, and shared.
Most teams are at Level 1 or 2. We operate at Level 4 today: agents learn from each other's sessions, share precedent across workflows, and the memory system maintains itself. Level 5 is the full org-wide knowledge library.
The architecture decomposes into three layers running on different timescales. Most systems have Memory. Few have Learning. Almost none have all three.
A Memory failure is data loss. A Learning failure is a missed insight or false lesson. A Personalization failure is serving the wrong context or overwhelming the agent. Naming the layers prevents conflating a retrieval problem with a storage problem.
Agent memory gives agents access to a store. The store is passive. Agentic memory manages itself via tool calls: ingesting, evaluating, connecting, consolidating, and forgetting. The memory layer is not a database with an API. It is an active participant in its own maintenance. We are building agentic memory.
| Capability | Typical RAG / vector store | Living Memory + Alexandria |
|---|---|---|
| Retrieval | Embedding similarity, one-shot | Workflow-scoped, entity-anchored, multi-pass (berrypicking), token-budgeted |
| Learning | None. Re-embed on manual update. | Session-end reflection, digestive pipeline, lessons shared across agents |
| Forgetting | None. Accumulate forever. | Decay tiers, condensation, supersession, stale detection. Forgetting is architecture. |
| Connections | Implicit (cosine distance) | Typed, weighted, entity-anchored. Decisions link to assumptions link to evidence. |
| Quality | Whatever was embedded | Trust tiers, immune system (write-time validation), quality-gated claims |
| Presentation | Chunks returned by query | Claims installed as capabilities. [[wiki-links]] carry reasoning inline. Progressive disclosure. |
We pressure-tested the architecture against LangChain, Engram, ALMA, MemGPT/Letta, Cognee, MAPLE, Anthropic's memory tool, a major 2026 academic survey, 8 RAG architecture patterns, and more. What we found:
Hierarchical token-level memory (academic gold standard). Memory evolution (decay, condensation, supersession) ahead of the field. Propositional framing matches the "retrieve-then-generate" paradigm the industry is moving toward. Forgetting design is the most complete in any source evaluated.
Episodic memory (raw case records beneath lessons). Context pressure handling for long-running agents. Shared memory access control for multi-agent writes. Memory explainability and retrieval attribution. Event-triggered learning for critical failures.
Decay tiers (Engram). Memory strengthening (Cognee). Offline consolidation cycle (CLS theory). Context pressure events (Anthropic). Reflect-generate-verify for methodology changes (ALMA). M/L/P naming (MAPLE).
RAG is adding graphs. Graphs are adding agents. Agent memory is adding learning loops and forgetting. Context engineering is becoming the discipline that ties them together. Living Memory and Alexandria sit at the intersection: agentic memory on a knowledge graph, with context engineering as the serving layer.
Memory is the multiplier. Agency is the force.