AI agents are getting better at reasoning, coding, and using tools. But one basic problem remains:**When the session ends, much of what the agent learned ends with it.**Tigerless Labs’ Agent Memory addresses this with a persistent memory runtime built around plain Markdown, local ranked retrieval, and an independent memory-management layer. The goal: memory that survives the session without becoming a black box.
The Problem: Agents Still Wake Up Forgetting
Long context windows help agents remember more during a session. They do not create durable memory between sessions.Retrieval-heavy systems — mem0, Graphiti, and the memory services built on them — use embeddings, vector search, knowledge graphs, or ranking pipelines. They can find relevant information, but often return opaque chunks from a separate memory system.Filesystem-based memory takes the opposite approach: the second-brain tradition, Obsidian-style vaults and the tools built around them. Markdown is readable, editable, and portable, but simply browsing files stops scaling as the store grows.Agent Memory takes both halves by putting them in different places: ranking lives in a disposable index, while relations live inside the files themselves.
Markdown Is the Memory
The core design is simple:Markdown files are the source of truth. The index is only a cache. Memories live as normal files, while a local SQLite/FTS5 index makes retrieval fast and ranked. Relations stay in the files too. Memories can point to related memories with Markdown links, track replacements with superseded_by, preserve their source through provenance, and gain topic structure from the directory tree. No separate graph database owns those edges. Delete the index and rebuild it, and the knowledge remains. That avoids the usual trade: a graph service can rank and relate but is harder to read, diff, or move; a vault is readable and portable but cannot rank. Agent Memory ranks like the first and reads like the second, because the index owns speed — not the knowledge.
Recall Without Flooding the Context
Retrieval is progressive rather than all-or-nothing.Agent Memory can move through:Index → Abstract → Outline → Full Memory → Raw MaterialThe agent can skim results first, then open only what matters. A simple question may need an abstract; a harder one can follow links or return to the original source. This reduces context cost, but more importantly, it keeps retrieval inspectable. Instead of receiving an opaque chunk chosen by the memory system, the agent can navigate the store like a person navigating a vault.
Memory Needs a Lifecycle
Long-term memory also needs to change.Agent Memory handles writes at conversation boundaries rather than relying on the agent to remember to save something. An independent sleep-time Manage layer can consolidate and update memories on its own schedule.Deletion is more cautious: unattended management can propose it, but user confirmation is required. Updates can supersede older memories without erasing their history.Memory becomes a lifecycle, not just a pile of stored text.
One Store, Multiple Agents
Claude Code and Codex CLI can share the same memory store, while other shell-capable agents can access it through the CLI.The library itself contains no LLM client and requires no additional API key. The memory stays local, inspectable, and portable across agent environments.
Does It Actually Help?
Tigerless Labs evaluated Agent Memory on LongMemEval-S, using a haystack bounded to 12 sessions per episode. Agent Memory, MemCore, and a no-memory control wrote separate stores from the same 120 episodes, then took a closed-book exam in fresh sessions across two replays, graded by a calibrated LLM judge and compared question by question.Both memory systems substantially outperformed the no-memory control. Agent Memory answered significantly more than MemCore in both replays, in the same direction.Two caveats matter: the bounded haystack means these results are not directly comparable with published LongMemEval scores, and the test is end to end — writing and retrieval differ together — so the gain cannot be assigned to either component alone.
MemCore v0.2.0, driven by its own skill file, on a single host; its binary needed a one-line patch to run on this machine’s glibc, and its write pass was interrupted by an account session limit and resumed after reset. One host, one model; results do not generalize to others.
Why It Matters
The interesting question is not simply whether an AI agent can have memory. It is where that memory lives and who controls it. Agent Memory keeps the source of truth in readable Markdown, makes retrieval local and ranked, lets different agents share the same store, and manages memory as an evolving lifecycle.Retrieval systems have ranking and relations. Vaults have files you own. Agent Memory declines the trade. Better agents may not only need larger context windows. They may need memory they can retrieve, inspect, maintain, and carry from one session to the next.
