Skip to content
FrankX.AI
Research Hub/Agentic Memory

Agentic Memory

How context compounds across tools and sessions

TL;DR

Most agents still restart cold every session. Production agentic memory in 2026 is multi-layer infrastructure: working context + episodic/semantic/procedural stores + controllers that decide store/retrieve/update/summarize/discard. Leaders split by architecture (vector-first Mem0, temporal graphs Graphiti/Zep, OS-tiered Letta). Sovereignty requires local-core ownership with adapters — not a closed cloud memory black box. Memory alone does not fix skill composition or multi-domain life; it is the compounding layer of agentic life architecture.

Updated 2026-07-1616 source references4 claims indexed

Research briefs like this, when the evidence is ready. Source links, limitations, and open questions.

Subscribe

5

Core memory ops (store/retrieve/update/summarize/discard)

Agentic Memory RL research

~61k

Mem0 GitHub stars order-of-magnitude (2026)

GitHub mem0ai/mem0

3

Dominant architecture bets

Vector / Temporal graph / OS-tiered

local_core

Sovereign authority pattern

starlight-memory doctrine

01

The Problem: Context Does Not Compound

Chat products, coding agents, and tool runtimes each hold partial state. Users restate preferences, project facts, and decisions across Claude Projects, Cursor, Hermes profiles, Telegram bots, and web apps. Without a shared memory contract, specialization cannot compound and multi-session agents regress to clever amnesia. Context engineering manages the window; agentic memory manages what survives the window.

Session amnesia

Failure

New threads lose working agreements, style rules, and decisions unless explicitly rehydrated.

Tool silos

Failure

Each harness stores memory differently (or not at all). Cross-tool recall is manual copy-paste.

Context rot

Failure

Naively dumping history into long windows degrades attention (lost-in-the-middle / RULER-class effects).

Fake continuity

Failure

Vendor "memory" that cannot export, audit, or delete under user control is convenience without ownership.

02

Memory Taxonomy For Agents

Useful systems separate memory by purpose and lifetime, then add a controller. Collapsing everything into one vector collection is the most common design error.

Working / STM

Type

Current turn state, scratchpads, tool results — ephemeral, high churn, aggressively compressed.

Episodic

Type

What happened: runs, decisions, handoffs, receipts with timestamps and actors.

Semantic

Type

Stable facts, preferences, entities, brand voice, architecture decisions — pocket-sized truths.

Procedural

Type

How to do work: skills, playbooks, hooks, SOPs that load on demand.

Controller

Type

Policy for store/retrieve/update/summarize/discard — rules, heuristics, or RL-trained ops (AgeMem-class research).

03

Architecture Bets In 2026

Three architecture bets dominate. None wins every axis. Production stacks often combine: local markdown authority + optional graph/vector accelerators + harness-specific working memory.

Vector-first memory layers

Bet A

Mem0-class systems: extract memories, embed, retrieve. Fast adoption, strong ecosystem, weaker pure temporal multi-hop unless graph options enabled.

Temporal knowledge graphs

Bet B

Graphiti/Zep-class: facts as time-stamped relationships. Stronger on "what was true when" and multi-hop entity questions.

OS-tiered agent memory

Bet C

Letta/MemGPT lineage: treat context as RAM and external store as disk; agent edits memory blocks deliberately.

Sovereign local core + adapters

Bet D

Starlight Memory doctrine: filesystem-native atoms with hybrid recall as authority; Mem0/Hindsight/etc. as scored adapters behind a provider contract.

04

Product Landscape (Memory Systems)

Compare systems by architecture, open source posture, self-host path, temporal strength, and sovereignty — not by star count alone. Stars measure ecosystem; they do not measure export rights or multi-agent provenance.

Mem0

Product

Universal memory layer; largest community signal; Apache 2.0 core + managed cloud; strong personalization path; optional graph modes in later stacks.

Zep + Graphiti

Product

Temporal context graphs; Graphiti OSS engine; production Zep platform for governance/retrieval; strong temporal reasoning reports on LongMemEval-class benches.

Letta

Product

Stateful agents with self-editing memory; OS metaphor; strong for long-horizon agents that manage their own memory blocks.

LangMem

Product

LangGraph-native memory SDK for teams already on LangChain state machines.

Starlight Memory

Product

Provider contract + local_core authority + MCP tools (recall/search/remember) for multi-harness coding fleets; evaluation-driven defaults.

Others to watch

Watch

Cognee (graph-first), Supermemory (MCP-first), Honcho/Hindsight-class systems, pure vector DBs (Pinecone/Weaviate/Qdrant) as storage not full memory OS.

05

Patterns That Make Memory Compound

These patterns turn storage into compounding intelligence. Implement them as policy, not hope.

Read-before-reason / write-after-act

Pattern

Standard agent loop: retrieve relevant memory, act, then write durable deltas with provenance.

Memory that earns its spot

Pattern

Prefer durable rules and atomic facts over raw chat dumps. Every persistent token taxes every future turn.

Progressive disclosure

Pattern

Keep procedural knowledge in skills loaded on demand; do not paste entire skill libraries into every prompt.

Actor-aware multi-agent memory

Pattern

Track who said/did what across agents to prevent credit and contradiction collapse in swarms.

Compaction + structured notes

Pattern

Anthropic-class techniques: compact history, keep structured notes outside the polluted transcript.

Export and dual-write policy

Pattern

Local vault is canonical; cloud mirrors are derived. Deletion and retention must be enforceable.

06

Evaluation: Prove Memory Works

Without evals, memory is a marketing checkbox. Use public benchmarks for recall/temporal ability and private estate evals for your real harnesses.

LongMemEval

Bench

Long-horizon chat memory abilities: extraction, multi-session reasoning, temporal updates, abstention.

LOCOMO

Bench

Multi-session dialogue recall and multi-hop reasoning across long conversations.

Trajectory + memory audits

Bench

Did the agent retrieve the right memory before acting? Did it write the decision after? Score intermediate steps.

Provider scorecards

Bench

Recall quality, contradiction rate, latency, cost, privacy, exportability — Starlight Memory observatory pattern.

07

Sovereignty And Security

Life memory includes health, family, finance, brand strategy, and client work. Treat memory systems as regulated-adjacent infrastructure even when product UX feels casual.

Ownership

Gate

You must be able to export, delete, and re-host memory atoms without vendor permission theater.

Privacy classes

Gate

Route by classification: public, internal, private-life, regulated. Block cloud writes for forbidden classes.

No silent training

Gate

Contractual and technical controls against using private life memory as training fuel.

Process model

Gate

Dozens of coding agents per machine: heavy memory providers must be shared daemons/APIs, not one runtime per terminal.

08

From Memory Layer To Life Infrastructure

Agentic memory is the compounding layer of agentic life architecture. Pair it with skill composition, multi-domain modules, and quality receipts or you will rebuild the same five failure modes with a prettier retrieval UX.

With ACOS

Integration

Skills and hooks load procedural memory; session start restores working agreements; stop hooks write durable lessons.

With ALOS

Integration

Domain packages (business, creator, health, family, investor) share SIP/SIS memory nodes without cross-contaminating private data.

With evals

Integration

starlight-evals-class harnesses test retrieval + agent trajectories, not only chat recall quizzes.

With ops

Integration

Handover protocols and ledgers make multi-session, multi-human, multi-agent continuity operational.

Key Findings

1

Context engineering manages the window; agentic memory manages what survives the window across tools and sessions

2

Collapsing all memory into one vector collection is the most common production failure mode

3

Three dominant architecture bets in 2026: vector-first layers, temporal knowledge graphs, OS-tiered self-editing memory

4

Mem0 leads ecosystem breadth; Graphiti/Zep lead temporal graph reasoning; Letta leads OS-style long-horizon memory management

5

Sovereign pattern: local_core authority + scored adapters + privacy-class routing + exportable markdown/JSON atoms

6

Multi-agent systems need actor-aware provenance or they lose "who decided what" — a reliability problem, not just debugging

7

Benchmarks that matter: LongMemEval, LOCOMO, plus trajectory-aware memory audits in your real harness

8

Memory is necessary infrastructure for agentic life architecture but insufficient without composition, gates, and multi-domain modules

Research Transparency

Limitations

  • Published LongMemEval/LOCOMO leaderboard numbers are often vendor-reported on specific model versions and dates
  • GitHub star counts change rapidly and are not quality metrics
  • Managed cloud features diverge from open-source engines (e.g., Graphiti vs full Zep platform)
  • Private life memory requirements (health/family/finance) exceed typical chatbot memory product assumptions

What We Don't Know

  • ?Whether RL-trained memory operation policies will outperform engineered controllers in real multi-tool founder workloads
  • ?Stable interoperability standard for memory atoms across Claude/Codex/OpenAI/Gemini ecosystems
  • ?Best default forgetting curves for personal vs enterprise tenants
  • ?How much temporal graph complexity pays for itself outside CRM/entity-heavy agents
Evidence Grade:Grade B(Industry reports from credible firms)

Frequently Asked Questions

No. Long context helps within a window but does not solve cross-tool silos, export, privacy routing, or context rot. Memory systems decide what survives and what is retrieved next session.

Sources & References

From research to practice

Learn these tools hands-on

The research maps the landscape. These portals curate the videos, docs, and experts to actually build with the platforms it covers.