BUILDERS USE THE WORD MEMORY FOR FIVE DIFFERENT THINGS.

→ research.md §1. confusing these is the most common reason agent stacks break.

FOUR WINGS.
one archive.

A MEMORY TOOL + MARKDOWN FILES OUTSIDE THE CONTEXT.

→ anthropic.com / engineering / effective-context-engineering-for-ai-agents. solves cost and latency. does not solve persistence across sessions.

LAB 1. CLAUDE CODE'S MEMORY.MD, LIVE.

→ MEMORY.md is the librarian's index card stack. context comes and goes; the catalog persists.

VECTORS WIN ON SIMPLICITY. GRAPHS WIN ON TIME.

→ arXiv:2602.05665 (graph-based agent memory taxonomy, feb 2026). arXiv:2601.03236 (MAGMA, the "graphs eat vectors" thesis, jan 2026).

THREE FRAMEWORKS.
one wing. apache 2.0 all the way down.

→ talk section order is locked: zep first (the temporal case lands cleanest), then letta, then mem0. comparator table follows.

EVERY EDGE CARRIES FOUR TIMESTAMPS.

"what was true on this date?"

→ Preston Rasmussen, Liu, Liu, Mocrii, Klein, Chalef. *Zep: A Temporal Knowledge Graph Architecture for Agent Memory.* arXiv:2501.13956. nominative-fair-use citation per apache 2.0 §6.

ADD AN EPISODE. ASK WHAT WAS TRUE.

from zep_python.client import Zep
from datetime import datetime, timezone

client = Zep(api_key="...")
graph_id = "ray_memory"

# write a temporal episode. the graph extracts entities + edges.
client.graph.add(
    graph_id=graph_id,
    type="message",
    data="Ray prefers jade-teal accents on event posters.",
    reference_time=datetime.now(tz=timezone.utc),
)

# later, in a new session, ask the graph what holds today.
results = client.graph.search(
    graph_id=graph_id,
    query="Ray's color preference for posters",
    search_filters={"valid_at": datetime.now(tz=timezone.utc)},
)

for edge in results.edges:
    print(edge.fact, edge.valid_at, edge.invalid_at)

→ runnable version with full provenance walk-through at /lab/zep. one graph, three episodes, one temporal query. 8 minutes.

THE AGENT OWNS THE BLOCKS. THE RUNTIME PERSISTS THEM.

the distinction. zep keeps truth in the graph (graph-owns-truth). letta keeps state in agent blocks (agent-owns-blocks). mem0 keeps it behind an API (api-owns-truth). same problem. three different owners.

SPAWN AN AGENT. EDIT ITS CORE. COME BACK TOMORROW.

from letta_client import Letta

client = Letta(base_url="http://localhost:8283")

# create an agent. core memory blocks are first-class state.
agent = client.agents.create(
    name="ray_assistant",
    memory_blocks=[
        {"label": "human", "value": "Ray runs Vibe Coding Nights at Frontier Tower."},
        {"label": "persona", "value": "I keep track of what Ray ships."},
    ],
    model="claude-sonnet-4-6",
    embedding="text-embedding-3-small",
)

# the agent can edit its own blocks via tool calls during a turn.
client.agents.messages.create(
    agent_id=agent.id,
    messages=[{"role": "user", "content": "remember that I prefer jade-teal accents."}],
)

# tomorrow. fresh process. same agent. same memory.
client.agents.messages.create(
    agent_id=agent.id,
    messages=[{"role": "user", "content": "what color did I tell you I liked?"}],
)

→ runnable at /lab/letta. spin up a local letta server, create an agent, watch core memory survive a process restart. 10 minutes.

THREE LINES. ZERO SUBSTRATE DECISIONS.

→ the pitch is operational simplicity. mem0 hides the substrate choice the other two surface. tradeoff: less control, less to break.

ADD. SEARCH. THAT IS IT.

from mem0 import Memory

m = Memory()

# write some memories tied to a user.
m.add("Ray prefers jade-teal accents on event posters.", user_id="ray")
m.add("VCN happens wednesdays at 7pm at Frontier Tower.", user_id="ray")
m.add("Ray hosted VCN #32 last week. Topic: tool-use UX.", user_id="ray")

# later, in a new session, retrieve what is relevant.
results = m.search(
    query="what color should the poster be?",
    user_id="ray",
    limit=5,
)

for hit in results["results"]:
    print(hit["memory"], hit["score"])

# forget a memory if it goes stale.
m.delete(memory_id=results["results"][0]["id"])

→ runnable at /lab/mem0. three messages, one search, one delete. the substrate is hidden by design. 5 minutes.

NO FRAMEWORK. JUST MARKDOWN. HIGHEST LEVERAGE TODAY.

The pattern emerged from nowhere and quietly became table stakes. A static markdown file that tells the agent how this codebase works, what conventions to follow, what to never touch. No vector store. No write path. Just words a human and a model both read.

# Life Automation Repo

# Doing tasks
- consequential messages (sponsors, investors) always go through
  Validate → Summarize → Approve → Act
- never run parallel Telegram connections (causes flood waits)
- credentials live in .env, never committed

# Voice rules
- no em-dashes, en-dashes, or hyphen connectors in outbound drafts
- lowercase headlines except where institutional names appear

→ cursor `.cursorrules` was first. claude code `CLAUDE.md` is the canonical agent-readable version. zero infrastructure cost. the most widely-shipped memory pattern of 2026.

THE AGENT IS WRITING ITS OWN INDEX CARDS RIGHT NOW.

→ first agent to curate its own procedural memory by default. lab: /lab/claude-md. init a new CLAUDE.md in 90 seconds, watch it grow.

FOUR LAYERS. FOUR JOBS. ONE TABLE.

→ the differences are about who owns truth: the graph (zep), the agent (letta), the api (mem0), or the file (CLAUDE.md). pick by ownership, not by feature list.

NONE OF THESE ARE SOLVED. PICK ONE AND BUILD.

→ research.md §4 · pull these directly from the 2026 frontier papers (arXiv:2603.07670, arXiv:2512.13564). every one is an unbuilt company.

THE PATTERNS THE FRAMEWORK HEADLINES MISS.

→ research.md §5. the rules-files pattern in general (`.cursorrules`, `CLAUDE.md`, `.windsurfrules`, `AGENTS.md`) is the layer that quietly won for most teams.

ONE QUESTION. ONE ANSWER. START THERE.

→ the questions are not competing. most production stacks pair a knowledge layer with a process layer. pick by question, not by brand.

FOUR LABS. ONE HOUR.

by 10pm, your agent remembers something it didn't at 7.

→ scan the QR on the deck chrome to pair your phone. no urls to memorize. labs run offline-friendly where possible.

THE NEXT SEVEN. ALREADY ON THE CALENDAR.

• 2026-05-20VCN #33 · Total Recall · memory for agentic systems (tonight)
• 2026-05-27VCN #34 · Toolsmith · build your own MCP server
• 2026-06-03VCN #35 · Well Known · make your site discoverable by agents
• 2026-06-10VCN #36 · Crosstalk · build your own A2A endpoint
• 2026-06-17VCN #37 · Settlement · build an x402 paywall
• 2026-06-24VCN #38 · Glass Box · trace agents with OpenTelemetry
• 2026-07-01VCN #39 · Browser Tax · instrument your site with WebMCP
• 2026-07-08VCN #40 · Hardpoint · build an agent that withstands red-teaming

→ free, builder-only, no pitches. RSVPs on luma.com/vibe-coding-nights. doors 7pm, talks 7:30, social 9 to 10.

THE PEOPLE WHO PUT THIS ROOM TOGETHER.

→ thanks to the F10 annex, Frontier Tower house staff, and every builder who showed up with a forgetting bug written down.

THE RUNNABLE PART. PICK A LANE.

one edge. four lifecycle stamps. a clock per fact.

→ Rasmussen et al. Zep: A Temporal Knowledge Graph Architecture for Agent Memory. arXiv:2501.13956. Source code: github.com/getzep/graphiti, file graphiti_core/edges.py. Nominative-fair-use citation per apache 2.0 §6.

extraction is eventual. the graph is the consistency boundary.

Every episode you write fires a chain of LLM calls. Entity extraction. Edge extraction. Conflict resolution. Embedding. The graph commits a few seconds after the call returns. Reads against the graph during that window get the old truth, on purpose.

→ reference: Rasmussen et al. arXiv:2501.13956 §4 "Pipeline." Source: graphiti_core/graphiti.py::add_episode. Latency numbers approximate, measured against gpt-4o-mini on a 200-node graph.

two search calls, three result shapes. pick by question type.

Zep ships graph.search and memory.search_sessions as the two public read paths. They hit different indexes, return different shapes, and answer different questions. The wrong one looks broken on the right query.

→ docs: help.getzep.com/searching-the-graph. Hybrid uses Cohere rerank by default in Zep Cloud, swappable to bge-reranker in self-host. The choice between modes 01 and 02 is usually a latency budget call, not a quality call.

zep cloud wraps graphiti. graphiti standalone is the engine alone.

→ standalone walk-through at /lab/graphiti-standalone (kuzu backend, ten-minute scratch graph, no hosted deps). Repo: github.com/getzep/graphiti. Cloud docs: help.getzep.com.

letta is an agent runtime, not a memory library.

→ blog post: letta.com/blog/letta-v1-agent. Original paper: Packer, Wooders, Lin et al. MemGPT: Towards LLMs as Operating Systems. arXiv:2310.08560. Loop reference: letta/agent.py::step (open source under github.com/letta-ai/letta).

core is a list of named blocks. the agent rewrites them.

Core memory is not a freeform string. It is a list of labeled blocks. Each block is a chunk the agent can read and overwrite by label. Two come default. You can add as many as you need.

from letta_client import Letta

client = Letta(base_url="http://localhost:8283")

# update one block on a live agent. the next turn sees the new value.
client.agents.blocks.modify(
    agent_id=agent.id,
    block_label="human",
    value="Ray runs VCN at Frontier Tower. Prefers jade-teal. Ships fast.",
)

# add a brand new keyed block at runtime.
client.agents.blocks.create(
    agent_id=agent.id,
    label="open_threads",
    value="VCN-33 deck due Mon. Awaiting Daniel quote.",
    limit=2000,
)

→ reference: docs.letta.com/concepts/memory-blocks. SDK methods agents.blocks.modify and agents.blocks.create per the v1 Python client. The dashboard at localhost:8283 renders blocks live.

archival is a vector store. letta hides the backend.

The Archival tier on slide 10 is not magic. It is a vector index. Letta abstracts the backend so the agent code does not change when you swap pgvector for sqlite-vec for Chroma.

# server-side: ~/.letta/config.toml
[archival_storage]
type = "postgres"
uri  = "postgresql://localhost:5432/letta"

# or, for a one-file local dev setup:
[archival_storage]
type = "sqlite-vec"
path = "./letta_archival.db"

# the agent code does NOT change. archival_memory_search() works either way.

→ reference: docs.letta.com/server/configuration. Source: letta/orm/archival_passage.py. The cloud default is pgvector. Local letta server defaults to sqlite-vec.

one runtime. three model lanes. three deployment shapes.

Letta does not bind to a single provider. The model field on an agent is a routing string. Change the string, the loop on slide 34 runs against a different brain. The blocks, the archival, the recall, do not move.

from letta_client import Letta

client = Letta(base_url="http://localhost:8283")

# same blocks. same archival. three different brains.
prod_agent = client.agents.create(
    name="ray_prod",
    memory_blocks=[{"label": "human", "value": "Ray runs VCN."}],
    model="anthropic/claude-sonnet-4-6",
    embedding="text-embedding-3-small",
)

dev_agent = client.agents.create(
    name="ray_dev",
    memory_blocks=[{"label": "human", "value": "Ray runs VCN."}],
    model="openai/gpt-4o-mini",            # cheaper, faster, for dev loops
    embedding="text-embedding-3-small",
)

offline_agent = client.agents.create(
    name="ray_offline",
    memory_blocks=[{"label": "human", "value": "Ray runs VCN."}],
    model="ollama/llama-3.1-8b",          # no network, runs on your laptop
    embedding="ollama/nomic-embed-text",
)

→ docs: docs.letta.com/models. Provider strings: openai/<model>, anthropic/<model>, ollama/<model>, letta/letta-free (free tier on letta cloud). Embedding strings follow the same pattern.

mem0 is three storage layers behind one method.

from mem0 import Memory

# expose the substrate. flip on the graph layer.
config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {"host": "localhost", "port": 6333},
    },
    "graph_store": {
        "provider": "neo4j",
        "config": {"url": "bolt://localhost:7687", "username": "neo4j", "password": "..."},
    },
    "llm": {"provider": "anthropic", "config": {"model": "claude-sonnet-4-6"}},
    "embedder": {"provider": "openai", "config": {"model": "text-embedding-3-small"}},
}

m = Memory.from_config(config)

# add() now writes to BOTH vector and graph.
m.add("Ray prefers jade-teal. He runs VCN at Frontier Tower.", user_id="ray")

# search() with relations=True returns the graph traversal.
hits = m.search("what color does Ray prefer", user_id="ray", filters={"include_graph": True})

→ docs: docs.mem0.ai. Source: github.com/mem0ai/mem0. Config shape per Memory.from_config. The default Memory() constructor uses local Qdrant + OpenAI embeddings + no graph + no reranker.

scope by category. tune the extractor. stop mem0 from saving noise.

The 3-line demo is the floor. Production mem0 needs scoping (which memories belong to which user, session, or agent) and filtering (which messages are worth keeping at all). Both are first-class.

from mem0 import Memory

# tune what counts as a fact worth keeping.
custom_extractor = """
You are extracting memories for a VCN host. Keep:
- explicit preferences ("I prefer X")
- commitments and dates
- relationships between named people and orgs
Drop: small talk, weather, transient logistics.
Return JSON: {"facts": ["fact 1", "fact 2"]}
"""

m = Memory(config={
    "llm": {"provider": "anthropic", "config": {"model": "claude-sonnet-4-6"}},
    "custom_fact_extraction_prompt": custom_extractor,
})

# scope by both user and session. add a category for later filtering.
m.add(
    messages=[{"role": "user", "content": "I prefer jade-teal posters. VCN is on Mondays."}],
    user_id="ray",
    run_id="session_2026_05_11",
    metadata={"category": "preferences", "source": "telegram"},
)

# search only inside one category.
hits = m.search("poster color", user_id="ray", filters={"category": "preferences"})

→ docs: docs.mem0.ai/core-concepts/memory-types. The custom_fact_extraction_prompt field lives at the top level of the Memory() config. The metadata dict is stored on the row and queryable via filters.

new fact contradicts old fact. mem0 mutates the store.

Mem0 calls itself self-improving memory. The practical version: every add() runs a conflict pass against existing memories. New facts can update, supersede, or be merged with prior ones. The store mutates in place rather than appending.

from mem0 import Memory

m = Memory()

# t=0. write the original.
m.add("I live in Brooklyn and work remote.", user_id="ray")

# t=1. write the update. mem0 will classify as supersede.
m.add("I moved to SF for the Sandbox VR job.", user_id="ray")

# the store now has SF, not Brooklyn.
hits = m.search("where does Ray live", user_id="ray")

# the audit trail exists. ask for it.
for h in hits["results"]:
    print(h["memory"], "->", h.get("history", []))

→ reference: mem0.ai/blog/state-of-ai-agent-memory-2026. The classify step is the load-bearing one. The LLM picks one of ADD / UPDATE / DELETE / NONE per candidate against per-neighbor pair. Verdict prompt lives in mem0/memory/main.py.

three lines is the demo. thirty lines is production.

The three-line drop-in is real. It is also a development setup. A mem0 deployment that handles thousands of users, real latency budgets, and an audit trail has thirty lines of config and policy wrapped around the same three verbs.

from mem0 import Memory
import logging

logger = logging.getLogger("mem0.ops")

config = {
    # backends. all self-hosted. no cloud round-trip.
    "vector_store": {
        "provider": "qdrant",
        "config": {"host": "qdrant.internal", "port": 6333, "collection_name": "vcn_memories"},
    },
    "graph_store": {
        "provider": "neo4j",
        "config": {"url": "bolt://neo4j.internal:7687", "username": "neo4j", "password": "..."},
    },
    "llm": {
        "provider": "anthropic",
        "config": {"model": "claude-sonnet-4-6", "temperature": 0.0, "max_tokens": 1024},
    },
    "embedder": {
        "provider": "openai",
        "config": {"model": "text-embedding-3-small"},
    },
    # tune extraction. drop the chatter, keep the facts.
    "custom_fact_extraction_prompt": OPS_EXTRACTOR_PROMPT,
    # forward every call to internal telemetry.
    "history_db_path": "/var/lib/mem0/history.db",
    "version": "v1.1",
}

m = Memory.from_config(config)

# wrap the surface for logging + retries.
def add_with_audit(messages, user_id, run_id, category):
    res = m.add(
        messages=messages,
        user_id=user_id,
        run_id=run_id,
        metadata={"category": category, "ts": int(time.time())},
    )
    logger.info("mem0.add", extra={"verdicts": res, "user_id": user_id})
    return res

operational simplicity is the pitch. the three lines on slide 13 are honest about the floor. the thirty lines here are honest about the ceiling. the gap is where production lives.

→ reference: github.com/mem0ai/mem0 readme, docs.mem0.ai/integrations. The from_config constructor is the only path that exposes the full surface. Default Memory() is the friendly cousin. Both call the same internals.

THE MEMORY TOOL IS A FILESYSTEM CALLABLE.

{
  "name": "memory",
  "description": "Read and write notes to a persistent markdown filesystem at /memories.",
  "input_schema": {
    "type": "object",
    "properties": {
      "command": {
        "type": "string",
        "enum": ["view", "create",
                 "str_replace", "insert",
                 "delete", "rename"]
      },
      "path": { "type": "string" },
      "file_text": { "type": "string" },
      "new_str":   { "type": "string" },
      "old_str":   { "type": "string" }
    },
    "required": ["command", "path"]
  }
}

→ anthropic.com / engineering / effective-context-engineering-for-ai-agents. the memory tool ships as a public beta in the messages API; storage is operator-managed (Anthropic does not host the markdown). the agent self-curates without any operator policy code.

AT 180K TOKENS THE HARNESS REWRITES THE TRANSCRIPT.

You are summarizing a long agent transcript so the
agent can continue without losing the thread.

KEEP verbatim:
  - the user's original task and any clarifications
  - decisions the agent made and why
  - file paths read or written
  - the last 5 turns of reasoning

DROP:
  - full file contents (cite path + range instead)
  - tool result bodies > 2KB unless the agent
    references them in later reasoning
  - repeated Grep or Bash output

Output: a markdown brief under 4K tokens.

→ anthropic.com / engineering / effective-context-engineering-for-ai-agents and the public Claude Code docs at code.claude.com / docs / en / context. compaction is one of the four levers; the other three are tool-result clearing, sub-agent delegation, and the memory tool.

THE AGENT CAN MARK A TOOL RESULT AS DONE.

→ anthropic.com / engineering / effective-context-engineering-for-ai-agents names tool-result clearing alongside compaction and sub-agent delegation. the messages API exposes it as a per-tool-call boolean the model sets when responding.

SPAWN A SUB-AGENT. KEEP THE NOISE OUT OF THE PARENT.

→ anthropic.com / engineering / effective-harnesses-for-long-running-agents. the framing is explicit: delegation is "memory hygiene by quarantine." Claude Code's `Agent` tool is the production reference; the Managed Agents SDK exposes the same primitive.

THE FILESYSTEM IS THE REAL CONTRACT.

~/.claude/projects/C--Users-jtole-Documents-2026-life/memory/
├── MEMORY.md                       # index, agent-written
├── user_profile.md                 # who Ray is
├── reference_directory.md          # names · tg · email
├── feedback_no_dashes.md           # voice rule
├── feedback_facilitator.md         # billing rule
├── project_self_hosted_kv.md       # self-hosted redis
├── project_youtube_ingest.md       # yt-dlp + groq
└── _archive/                       # aged-out entries

~/Documents/2026/life/
└── CLAUDE.md                       # human-written, project rules

→ code.claude.com / docs / en / memory. each entry carries frontmatter (name, description, type) so the agent can decide whether to load it. typical entry types: `user`, `feedback`, `project`, `reference`. inspect any live MEMORY.md to see the structure.

HOOKS ENFORCE. MEMORY ONLY ASKS.

{
  "hooks": {
    "Stop": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "node ~/.claude/hooks/atomic-commit-gate.js"
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          { "command": "node ~/.claude/hooks/session-writes-tracker.js" }
        ]
      }
    ]
  }
}
# Stop hook exits non-zero if `git status --porcelain` has output.
# The session refuses to end. The user sees the diff and decides.

→ code.claude.com / docs / en / hooks. real hook example from `~/.claude/settings.json` in the life repo. enforcement code beats prose policy when stakes are high. use both: prose to explain why, hook to make sure.

FIVE FILES. FIVE PARENTS. ONE PATTERN.

→ the honest read: four of the five are static markdown the human edits. Claude Code is the only one where the agent curates a sibling file the operator typically does not touch. That is the only structural difference. Everything else is naming, scoping, and which directory the harness scans.

A 200 LINE CLAUDE.MD
beats a vector store for most teams shipping today.

→ this is the case the next two years of agent tooling will either defend or kill. the bet here: even when frameworks like Letta and Mem0 win on persistent state, the procedural layer stays in markdown next to the code. it is too cheap, too diff-friendly, too human-legible to lose.

YOU CAN'T A/B TEST REMEMBERING.

"did my agent get better at remembering" is a research question, not a unit test.

→ LOCOMO paper: arXiv:2402.17753 · referenced by every 2026 memory framework as the leaderboard nobody quite trusts.

FIVE STEPS. THREE HOURS. NOT FREE.

→ ray's lab scaffolds the run loop: /lab/locomo-eval · skeleton, not a finished comparison. you bring the budget.

TWO AGENTS, ONE STORE. NOBODY HAS SHIPPED THIS.

→ if you ship a real answer here in 2026 you have a company. arXiv:2603.07670 §6 for the survey of attempts.

THREE WAYS TO POISON. ONE STORE. ZERO DEFENSES OUT OF THE BOX.

mnemonic sovereignty · the agent's memory must remain provably yours.

→ A Survey on the Security of Long-Term Memory in LLM Agents, apr 2026, arXiv:2604.16548 · this is where the term gets coined. read it before you ship a shared memory pool.

FIVE DEFENSES. PICK ALL OF THEM.

→ defense vocab from arXiv:2604.16548 §5 · honeypot pattern from lobsterhoney.com · the broader argument: signing + tiers + provenance is the minimum stack for any shared memory in 2026.

NOBODY PICKS ONE. THEY STACK THREE.

→ /lab/hybrid-stack walks case b end to end · case c lives in any agent-native product you respect · case a is what you have right now.

"NEVER FORGET" IS WRONG. RETRIEVAL GETS NOISIER EVERY DAY.

The honest production answer is a combination of all three, tuned per memory tier. Mem0 ships a softmax over recency × salience. Zep retains everything but marks edges invalid_at. CLAUDE.md forgets nothing and you pay for it in context bloat.

→ cost-latency tradeoff lives at arXiv:2603.07670 §4.3 · the actual code each framework runs is in their open-source repos. read it before you trust the marketing.

50 EVENTS A SESSION. 100 SESSIONS. DO THE MATH.

The risk is the same risk all summarization has. The summary loses the specifics that mattered. The edge case that triggered the bug, the off-handed preference the user only stated once, the contradiction between session 17 and session 42. Compressed away by a summarizer who didn't know what was load-bearing.

→ reflection pattern: arXiv:2603.07670 §3.3 · the practical implementation is in letta/letta under memory/summarize.py · keep the raw log even if you stop reading from it.

READ THESE IN ORDER. SKIP NONE.

→ all entries pulled from research.md §Sources · this is the reading list ray maintains. expect rotations every quarter as the field moves.

THREE PREDICTIONS. CHECK BACK IN 2027.

Build memory like you mean it. Or pay for it. vcn #33 · total recall · 2026-05-20

→ ray's bet table for 2027 · these are predictions, not facts. quote them back to me when you find them wrong.

DO YOU FIT IN CONTEXT, OR DO YOU NEED A LAYER?

WATCH A FACT GO STALE.

SAME PROBLEM, FOUR SHAPES.