Agent Memory & Knowledge Systems Compared (2026 Guide)

Most companies deploying AI agents hit the same wall about two months in: the agent forgets everything between sessions, can’t read the company’s actual knowledge (strategy docs, pricing logic, customer notes), and has no clean way to write what it learns back to the team’s knowledge base for human review. The toolkit for solving this is strong, but the question that matters for a mid-market team is different from the question developers ask. It isn’t “which API surface is cleanest.” It’s “how does a company actually maintain its knowledge, feed it to agents, let agents add to it, and keep humans in the loop?”

As of April 2026, there are five named systems worth comparing (Mem0, Zep, Letta, Cognee, and Cloudflare Agent Memory) plus a sixth path: maintaining knowledge as plain markdown and giving agents read/write access through a semantic search index.

In this article:

• The five questions to ask before you pick a memory system
• What’s off the shelf in 2026 — and what you can build yourself
• Mem0, Zep, Letta, Cognee, and Cloudflare Agent Memory, compared on the same scaffolding
• The markdown-vault path nobody else writes about
• A 4-step workflow for letting agents propose knowledge updates that humans review
• A decision framework matched to mid-market deployments

The memory problem every mid-market deployment hits in month two

The first month of an agent deployment usually goes fine. Then three things start happening at once.

First, the session reset. The agent forgets yesterday’s conversation and the user re-explains context every time. By week three, people are typing the same paragraph of background into the prompt every morning.

Second, the knowledge gap. The agent doesn’t know the company’s pricing logic, brand voice rules, approved vendor list, or customer service notes. Those documents live in Notion, Obsidian, Google Drive, an internal wiki, or scattered Slack threads. The agent has no path to any of them.

Third, the learning leak. The agent figures something out during a session (a customer preference, a corrected spec, a new policy detail) and the moment the session ends, that learning is gone.

These three failures are usually framed as a context-window problem. They aren’t. They’re an organizational-knowledge problem. The question is not “how does the agent’s brain hold more information,” it is “where does the company’s knowledge live, who maintains it, and how does the agent participate in that loop without quietly rewriting things humans haven’t reviewed?” Every system below is a different answer to that question.

The five questions to ask before you pick a memory system

A buyer needs a self-diagnostic, a short list of questions to score against any candidate. Five questions cover the field:

1. Context management. How does the agent decide what fits in its working memory right now? Some systems keep the last N messages, some retrieve relevant memories on every turn, some compress conversations into running summaries. The right answer depends on how long your sessions are.

2. Connected knowledge body. Where does the agent’s knowledge come from, and who maintains it? If the only knowledge the agent has is what users say during sessions, the system is closed-loop. If the agent can read the company wiki, customer records, or a curated knowledge graph, it’s connected. Mid-market deployments almost always need the connected version, because the team already has its knowledge somewhere and the agent needs to plug into it.

3. Automatic vs engineered memory. Does the system decide what to remember on its own, or do you tell it explicitly? Automatic extraction is faster to deploy and harder to audit. Explicit memory is slower to set up and easier to control. Most mid-market teams want explicit at first and automatic only after they trust the system’s judgment.

4. Human-agent merge. Can humans read what the agent has learned, edit it, and contribute to the same knowledge base outside the agent loop? The agent should not be the only writer to its own memory. The human team needs a seat at the same table, ideally using normal tools (text editors, wikis, IDEs) rather than a separate “memory dashboard.”

5. Current limits. What does this system not do today? Every memory system has gaps. Some don’t handle entity changes over time, some don’t support multi-tenant scoping, some are private beta with no published pricing. Naming the limits before you commit saves the second deployment from fighting the first one’s blind spots.

These five run as a checklist against every system below.

The 2026 landscape — what’s off the shelf, what you build yourself

There are two paths through this market.

Off the shelf. Opinionated APIs and managed infrastructure. Integration time is days. Trade-offs are vendor lock-in, less control over how memory gets extracted and stored, and pricing models that are usually opaque until you scale. The named players are Mem0, Zep (with its open-source component Graphiti), Letta (formerly MemGPT), Cognee, and Cloudflare Agent Memory.

Build it yourself. Maintain the company’s knowledge as files, usually markdown, in a versioned folder. Index them with a local semantic search tool. Give agents a query interface and, optionally, a write-to-a-review-folder interface. Integration is longer up front, you own the operational complexity, and no vendor will support you. The advantages: knowledge stays portable, humans use normal tools to maintain it, and the cost is essentially infrastructure-only.

There’s also an architectural axis that cuts across both paths. Memory systems tend to fall into one of three patterns:

• Vector-only. Embed everything, retrieve by similarity. Fast, simple, weak on temporal and relational queries.
• Vector plus knowledge graph. Embed for similarity and extract entities/relationships for graph traversal. Better for “who owns what” and “what changed when” questions.
• Tiered or agent-managed. The agent itself decides what to keep in working memory and what to page out to longer-term storage. More flexible, harder to reason about.

Vectorize’s 2026 framework comparison introduced this taxonomy in clean form, and it’s a useful overlay when reading the rest of this article.

The five systems, compared

Mem0 — the personalization memory layer

Mem0 is a vector + graph + key-value memory layer designed to give assistants and support agents persistent, scoped recall about end-users. Best for chatbots, support agents, and deployments where the same users return repeatedly.

The architecture combines three storage layers (vector, graph, key-value) with a four-scope memory model: user_id, agent_id, run_id, app_id, plus an optional org_id. Memories are extracted automatically from conversations and stored against whichever scopes apply. According to Mem0’s State of AI Agent Memory 2026 report (citing the ECAI 2025 paper, Chhikara et al.), Mem0 scores 66.9% on the LOCOMO benchmark at 0.71s median latency using around 1,800 tokens per conversation, versus a full-context baseline of 72.9% at 9.87s and around 26,000 tokens — roughly 14x the token cost for under 6 points of accuracy. The graph-enhanced variant (Mem0g) scores 68.4% at 1.09s. Mem0 publishes both the benchmark and the comparators, so treat absolute numbers as vendor-favorable; the latency and token-cost gaps are directionally useful regardless.

On the five questions:

• Context management: retrieves relevant memories per turn, scoped by user/agent/run/app/org.
• Connected knowledge body: partial. Mem0 holds what users say; pulling the company’s existing knowledge in is custom work.
• Automatic vs engineered: automatic extraction by default, with explicit add/update APIs available.
• Human-agent merge: weak. Humans can call the API, but the workflow is developer-shaped, not knowledge-worker-shaped.
• Current limits: no native human-review workflow. The four-scope model is the closest the field gets to multi-stakeholder memory but it’s still agent-centric.

License: Apache 2.0 with around 48,000 GitHub stars per dev.to’s 2026 framework roundup. Atlan’s 2026 comparison also notes Mem0 has raised $24M in funding and holds SOC 2 compliance. Repo: github.com/mem0ai/mem0. Managed cloud has a free tier; production pricing is usage-based.

Zep / Graphiti — the temporal knowledge graph

Zep models memory as a temporal knowledge graph: facts have a time dimension, so “Alice owned the budget until February, then Bob took over” is a first-class query rather than a string-similarity guess. The open-source component is Graphiti; Zep Cloud is the managed product on top.

The temporal dimension matters most for production CRM and project agents, anywhere entities change relationships over time and the agent needs “what’s true now” separated from “what was true six months ago.” Zep groups conversations into episodes, summarizes them, and indexes the resulting graph. It scores 63.8% on LongMemEval per Atlan’s comparison, the strongest published number for temporal queries, versus Mem0’s 49.0% on the same benchmark.

One trade-off worth flagging: DevGenius’s builder comparison reports that immediate post-ingestion retrieval often misses correct answers because Zep’s graph processing runs in the background; correct answers tend to surface hours later once the graph catches up. The same piece notes Mem0’s published critique that Zep’s memory footprint can exceed 600,000 tokens per conversation versus Mem0’s ~1,800. That critique comes from Mem0, but the order-of-magnitude gap is consistent across third-party reports.

On the five questions:

• Context management: episode-grouped, summarized, retrieved with temporal awareness.
• Connected knowledge body: partial. Strong inside the graph it builds, weak at pulling external markdown or wiki content in without custom ingestion.
• Automatic vs engineered: automatic extraction, explicit graph editing available.
• Human-agent merge: weak. Humans interact with Zep through Zep’s tools, not their own.
• Current limits: retrieval delay until graph processing completes. No native human-review workflow.

License: Graphiti is open source; Zep Cloud is usage-based. Around 24,000 GitHub stars per the dev.to roundup. SOC 2 compliant per Atlan.

Letta (formerly MemGPT) — OS-inspired tiered memory

Letta models agent memory after an operating system. Main context is RAM (what’s in the prompt right now). Archival memory is disk (long-term storage the agent can search). The agent itself decides what pages in and out via tool calls. Originally published as MemGPT, the project rebranded in 2024 and continues under the same architecture.

Best for long-running agents that need effectively unlimited memory and where you’re willing to trust the agent with its own paging decisions: research assistants, coding assistants on multi-week projects, deployments running hundreds or thousands of turns. The trade-off is that “the agent decides what to remember” is harder to audit than “the system decides on rules you wrote.”

On the five questions:

• Context management: tiered RAM/disk model with agent-driven paging.
• Connected knowledge body: partial. Archival memory can hold ingested documents, but you’re operating Letta’s storage, not the company’s existing knowledge base.
• Automatic vs engineered: agent-managed, a third path between fully automatic and explicitly engineered by the operator.
• Human-agent merge: weak. Humans can call the API; no native co-edit workflow.
• Current limits: auditing what the agent chose to remember (and discard) is harder than with explicit-rule systems.

License: Apache 2.0, around 21,000 GitHub stars per the dev.to roundup. Managed cloud available; self-hosted deployment is well-documented.

Cognee — knowledge graph from unstructured data

Cognee is the closest existing system to “feed the company’s documents in and let the agent reason over them.” Its pipeline ingests raw documents, conversations, and external sources, extracts entities and relationships, builds a knowledge graph, and retrieves by graph traversal combined with vector search. The entry point is unstructured documents (not conversation logs) and the graph is the primary retrieval surface, which makes Cognee strong for institutional knowledge and weaker for fast conversational personalization. Best for research-heavy agents and deployments where the inputs are messy documents rather than clean conversations.

On the five questions:

• Context management: graph traversal plus vector retrieval; long-form document support is the strength.
• Connected knowledge body: stronger here than the conversational-memory peers. Ingestion is the design center.
• Automatic vs engineered: automatic extraction with configurable pipelines.
• Human-agent merge: partial. Humans curate the input documents, but Cognee’s representation of them is opaque to non-engineers.
• Current limits: no native human-review workflow on agent-added knowledge; managed-service pricing not transparent at the time of writing.

License: open core with around 12,000 GitHub stars per the dev.to roundup. Managed cloud available.

Cloudflare Agent Memory — the April 2026 entrant

Cloudflare announced Agent Memory in private beta on April 17, 2026. It’s the most significant new entrant this year, shipping as a managed service running on Workers, Durable Objects, and Vectorize.

Five operations (ingest, remember, recall, forget, list) cover the API surface. Ingestion runs as a two-pass pipeline at 10,000-character chunks with two-message overlap, with an eight-check verifier filtering extracted memories before they land. Memories are typed into one of four classes: Facts (atomic stable knowledge), Events (timestamped happenings), Instructions (procedures), and Tasks (ephemeral). A profile model can be shared across multiple agents and humans, the closest any managed service gets to a multi-stakeholder memory layer. Cloudflare also committed publicly that customer memory is exportable (“your memories are yours; every memory is exportable”), which most managed services don’t.

On the five questions:

• Context management: typed retrieval (Facts/Events/Instructions/Tasks) with verifier-gated ingestion.
• Connected knowledge body: partial. Designed primarily for conversational and event-driven inputs; document ingestion is supported but not the design center.
• Automatic vs engineered: automatic with a strong verifier in the loop.
• Human-agent merge: the shared-profile model gestures toward this, but the example in the launch post is “two agents share memory,” not “humans write the source of truth.”
• Current limits: private beta with no published pricing; Cloudflare-ecosystem dependency; production proof points are weeks old, not years.

License: managed service, no open-source release. Pricing: not yet published as of April 2026. Best fit: teams already on Cloudflare who want the lowest-friction managed memory layer and are comfortable being early adopters.

The build-it-yourself path: markdown vault plus semantic search

A folder of markdown files plus a local semantic search index is a legitimate competitor to all five managed paths above, especially for mid-market companies that already maintain knowledge in Notion, Obsidian, or git repos. This is one of the patterns we’ve watched work in practice — see how production agent teams handle memory in practice for the operational shape.

The pattern is simple. Maintain company knowledge as plain markdown in a versioned folder (an Obsidian vault, a git repo, a GitHub wiki, a Notion export). Index it with a local semantic search tool. Give agents read access through a query tool that returns matching files (or excerpts) with provenance. Optionally, give the agent write access to a designated subfolder where new notes go for human review before promotion into the canonical base.

The advantages stack up quickly. Knowledge stays portable: no vendor owns your facts, and migrating to a different agent platform means changing the query tool, not exporting and reformatting a database. Humans edit knowledge using normal tools (text editors, Obsidian, IDEs, GitHub PR review), so there’s no separate “memory dashboard” anyone has to learn. The same knowledge base feeds multiple agents and the team simultaneously. Cost is infrastructure-only.

The pattern has a documented public example. A February 2026 walkthrough at eastondev.com describes configuring an agent platform’s Obsidian-vault skill to sync conversation memory as Markdown notes with bidirectional links and structured directories (session logs in one folder, knowledge base in another). When Perplexity is asked about bidirectional human↔agent knowledge sync in 2026, that walkthrough is the project it cites: the only documented end-to-end pattern at the time of writing. For a longer-form view of the same shape, see how a real production pipeline uses memory across multiple stages.

Tools that fit this lane: Obsidian for the markdown editor and graph layer; a local semantic search index combining BM25 and vector search over the vault; LangMem or LlamaIndex memory modules when you want a memory abstraction pairable with a markdown backend instead of a SaaS layer.

When this path is the wrong answer: temporal entity tracking is non-trivial to build (use Zep), agent-managed paging across very long sessions is also non-trivial (use Letta), and if you genuinely don’t want any infrastructure to operate, the managed services exist for a reason.

The bidirectional sync question — how knowledge flows both ways

Most teams treat agent memory as one-way. The agent reads from some knowledge, operates on it, and the work product evaporates. The systems that actually work in production close the loop: agent reads, operates, writes back to a holding area, human reviews, knowledge gets promoted into the canonical base. Four steps, all of them necessary.

Step 1: Source of truth lives with humans. The canonical knowledge base, the place where the company’s strategy, pricing, customer details, and policies actually live, is something humans maintain primarily. An Obsidian vault, a Notion workspace, an internal wiki, a git repo of markdown files. Whatever it is, the humans on the team are the authoritative authors. This principle of building your own knowledge base rather than letting it live inside a vendor’s database is what makes the rest of the workflow possible.

Step 2: Agent reads with provenance. When the agent answers a question or makes a decision, it cites which document (or which memory record) the answer came from. No “trust me” responses. Provenance is non-optional, because without it humans can’t audit what the agent is doing.

Step 3: Agent writes to a review queue, not the source of truth. When the agent learns something new (a customer corrected a fact, a project changed scope, a pricing exception was approved) it writes that new note to a pending/ or inbox/ folder. Never directly to the canonical base. The agent’s job is to propose, not to publish.

Step 4: Human review promotes or rejects. A periodic review pass (daily for high-velocity environments, weekly for most) either promotes the agent’s proposed notes into the canonical base or rejects them. The canonical base only grows under human authority. The review interface is whatever the team already uses: a folder, a Pull Request, a Notion page with a checkbox.

How each system maps to these steps tells you the most about whether it’s a fit:

• Mem0: step 2 strong (four-scope provenance), step 1 partial, steps 3 and 4 require custom work.
• Zep: step 2 strong (episode-level provenance), step 1 partial, steps 3 and 4 require custom work.
• Letta: step 2 harder (paging decisions aren’t always traceable), steps 3 and 4 require careful tool wrapping.
• Cognee: step 1 strongest (document ingestion is the design center), step 2 partial, steps 3 and 4 require custom work.
• Cloudflare Agent Memory: typed classification and shared profiles gesture at multi-stakeholder memory; step 4 is the gap.
• Markdown vault plus semantic search: step 4 is just “humans editing a folder” or “merging a Pull Request.” That’s where this path quietly wins. Steps 1–3 require operational discipline rather than a vendor.

No system natively implements step 4. All of them assume the agent has authority to update memory directly. The systems that come closest do so by accident (Cloudflare’s shared profiles, Mem0’s scoped models) not by design. The markdown-vault path makes step 4 a workflow choice instead of a feature request.

A decision framework for picking the right system

Read the framework as “if your situation is X, start with Y”:

• Already on Cloudflare and want low-friction managed: Cloudflare Agent Memory (private beta; confirm access first).
• Adaptive personalization for end-users (chatbot, support, returning users): Mem0.
• Entities and relationships change over time (“who owned this account in February”): Zep / Graphiti.
• Long-horizon agents needing effectively unlimited memory: Letta.
• Ingesting unstructured documents, reasoning over a knowledge graph: Cognee.
• Full ownership, portability, humans as first-class authors: markdown vault plus semantic search.
• Already on LangChain/LangGraph or LlamaIndex: use their memory modules first; revisit only if you outgrow them.

Most mid-market deployments end up combining a markdown vault for canonical knowledge with one of the off-the-shelf layers for transient session memory. The vault holds what the team owns; the SaaS layer holds what the agent needs to remember about an active conversation. That split keeps canonical knowledge portable while letting the agent operate at the speed users expect.

Open problems in the field

The agent-memory category is roughly eighteen months old as a distinct discipline. A few caveats apply across all six paths above. No system natively implements the human-review-promotion gate; all assume the agent has authority to update memory directly. LOCOMO and LongMemEval are useful but easy to overfit (Cloudflare’s launch post says so directly) so treat scores as directional. Most managed services route conversation extraction through their own LLMs — fine for some businesses, a deal-breaker for others. None publish per-query pricing in a way that lets a buyer model real-world cost ahead of time. Cloudflare publicly committed to memory export; most others have not. Voice agent memory is a distinct emerging sub-problem.

The market gap is wide enough that one of the major systems will likely close it within twelve months.

FAQ

What is the best AI agent memory system in 2026?

There isn’t a single best. Mem0 leads on personalization and benchmark scores. Zep / Graphiti leads on temporal queries. Letta leads on long-horizon agent-managed memory. Cognee leads on unstructured-document ingestion. Cloudflare Agent Memory is the most significant new managed entrant. For deployments where humans need to be first-class authors of the knowledge base, a markdown vault plus a semantic search index is often the right answer.

Is Cloudflare Agent Memory open source?

No. Cloudflare Agent Memory is a managed service in private beta as of April 17, 2026, running on Workers, Durable Objects, and Vectorize. Cloudflare has committed publicly to making customer memory exportable, but the service itself is closed-source.

What’s the difference between Mem0 and Zep?

Mem0 is optimized for personalization, remembering things about end-users across sessions, with a four-scope memory model (user_id / agent_id / run_id / app_id). Zep is optimized for temporal knowledge, tracking how entities and relationships change over time using a knowledge graph. Mem0 is faster on retrieval; Zep is more accurate on “what was true when” questions. Per published benchmarks, Mem0 leads LOCOMO and Zep leads LongMemEval.

Can I use Obsidian as memory for an AI agent?

Yes. The pattern is to maintain company knowledge as markdown in an Obsidian vault, index it with a local semantic search tool, and give the agent a query interface. Optionally, give the agent write access to a review folder where humans promote or reject new notes. A February 2026 walkthrough at eastondev.com documents one full implementation.

How do I let an AI agent update my company’s knowledge base?

Don’t let it write directly. Use a four-step bilateral sync workflow: humans maintain the canonical knowledge base, the agent reads with provenance, the agent writes new learnings to a review folder (not the canonical base), and a periodic human review promotes or rejects them. None of the major managed memory systems implement step four natively, which is why the markdown-vault path is often the easiest fit.

If you don’t want to build this

If your business is hitting the memory wall and you don’t want to evaluate six options and stand up the bidirectional review workflow yourself, that’s the kind of work we do. We can run the memory architecture and the human-review workflow with you, so the canonical knowledge stays yours and the agent participates in the loop you already trust.