developer-tools

Zep Review: Memory Capture, Scope, and Forgetting (2026)

Name: Zep
Availability: InStock
Author: AI Demos

Developer-first memory for AI agents that captures workflow context well, but still needs stronger stale-memory and forget control.

Visit Zep

Multi-session memoryClient support contextScope isolationForget control tested

TL;DR — our verdictUpdated July 2026 · 18 test artifacts

Strong context memory, weaker lifecycle control

Where it wins

You need an API/SDK-backed memory layer for agents.
You want user, customer, and project context persisted across sessions.
You need inspectable summaries, entities, and graph views for debugging.

Main limitation

You need reliable forget/delete enforcement right now.

Pricing (verified plans)

Free 10,000 credits/month; 2 projectsFlex $125/month; 50,000 creditsFlex Plus $375/month; 200,000 creditsEnterprise Custom pricing

Strongest test artifacts

Persistent Memory Capture and Reuse →Memory Correction and Update Propagation →Memory Scope Isolation →

Our take

Zep is a strong developer-first memory layer for agent workflows. It captured user style, client history, project direction, and scope boundaries well, and the graph/UI made remembered context easy to inspect. The main weakness is lifecycle control: outdated client context and a forgotten preference still resurfaced after later corrections.

Demo walkthrough used during the test harness review.

In-Depth Review

Our detailed analysis of Zep — features, performance, and real-world testing.

AI Demos Team

Expert Reviewer

Verified Review

Feature-by-Feature Breakdown

Persistent Memory Capture and Reuse

Strong

▾

Test Summary

Feature tested: Persistent Memory Capture and Reuse

Result: Passed — Strong

Feature tested: Persistent Memory Capture and Reuse

Result: Passed

Verdict: Strong

Expected behavior: Stores user, customer, and project context and applies it later. In testing, Zep reused the founder's short direct style, remembered prior troubleshooting steps, and preserved project framing well enough to help with a later handoff note.

Test case: Text prompt → Image

Input type: Text prompt

Input used: Input artifact (Text prompt): Input

Observed output: Output artifact (Image): Zep acknowledged the user's work-style rules in a short, direct way and asked what they were working on next, showing the preference was captured rather than ignored. — Zep_Input1_Founder_Work_Preference_Created.png

Input artifact: Input artifact (Text prompt): Input

Output artifact: Output artifact (Image): Zep acknowledged the user's work-style rules in a short, direct way and asked what they were working on next, showing the preference was captured rather than ignored. — Zep_Input1_Founder_Work_Preference_Created.png

What changed: Text prompt transformed into Image

Test case: Text prompt → Image

Input type: Text prompt

Input used: Input artifact (Text prompt): Input

Observed output: Output artifact (Image): The later internal update stayed short, practical, and work-focused, which shows the saved style preference was retrieved and applied. — Zep_Input1_Internal_Update_Memory_Applied.png

Input artifact: Input artifact (Text prompt): Input

Output artifact: Output artifact (Image): The later internal update stayed short, practical, and work-focused, which shows the saved style preference was retrieved and applied. — Zep_Input1_Internal_Update_Memory_Applied.png

What changed: Text prompt transformed into Image

Test case: Text prompt → Image

Input type: Text prompt

Input used: Input artifact (Text prompt): Input

Observed output: Output artifact (Image): Zep kept the outreach email professional and concise instead of over-polishing it, so the saved style did not override the formal-email boundary. — Zep_Input1_Formal_Email_Boundary_Check.png

Input artifact: Input artifact (Text prompt): Input

Output artifact: Output artifact (Image): Zep kept the outreach email professional and concise instead of over-polishing it, so the saved style did not override the formal-email boundary. — Zep_Input1_Formal_Email_Boundary_Check.png

What changed: Text prompt transformed into Image

Test case: Text prompt → Image

Input type: Text prompt

Input used: Input artifact (Text prompt): Input

Observed output: Output artifact (Image): Zep captured the ACME support history and moved straight to SSO/IdP-level diagnosis instead of treating the issue like a fresh browser problem. — Zep_Input2_ACME_Client_Memory_Created.png

Input artifact: Input artifact (Text prompt): Input

Output artifact: Output artifact (Image): Zep captured the ACME support history and moved straight to SSO/IdP-level diagnosis instead of treating the issue like a fresh browser problem. — Zep_Input2_ACME_Client_Memory_Created.png

What changed: Text prompt transformed into Image

Test case: Text prompt → Image

Input type: Text prompt

Input used: Input artifact (Text prompt): Input

Observed output: Output artifact (Image): The follow-up reply skipped password reset, cache clearing, and browser-switching, and instead focused on SAML traces, IdP logs, and other higher-value diagnostic steps. — Zep_Input2_ACME_SSO_Followup_No_Repeated_Basic_Troubleshooting.png

Input artifact: Input artifact (Text prompt): Input

Output artifact: Output artifact (Image): The follow-up reply skipped password reset, cache clearing, and browser-switching, and instead focused on SAML traces, IdP logs, and other higher-value diagnostic steps. — Zep_Input2_ACME_SSO_Followup_No_Repeated_Basic_Troubleshooting.png

What changed: Text prompt transformed into Image

Test case: Text prompt → Image

Input type: Text prompt

Input used: Input artifact (Text prompt): Input

Observed output: Output artifact (Image): Zep understood the Memory for AI Agents project and organized the work around personal work brain, client relationship memory, and team handoff. — Zep_Input3_Project_Context_Created.png

Input artifact: Input artifact (Text prompt): Input

Output artifact: Output artifact (Image): Zep understood the Memory for AI Agents project and organized the work around personal work brain, client relationship memory, and team handoff. — Zep_Input3_Project_Context_Created.png

What changed: Text prompt transformed into Image

Test case: Text prompt → Image

Input type: Text prompt

Input used: Input artifact (Text prompt): Input

Observed output: Output artifact (Image): Zep preserved the proof-first rules and emphasized that observations need screenshots and artifacts, not just assertions. — Zep_Input3_Project_Rules_Captured.png

Input artifact: Input artifact (Text prompt): Input

Output artifact: Output artifact (Image): Zep preserved the proof-first rules and emphasized that observations need screenshots and artifacts, not just assertions. — Zep_Input3_Project_Rules_Captured.png

What changed: Text prompt transformed into Image

Test case: Text prompt → Image

Input type: Text prompt

Input used: Input artifact (Text prompt): Input

Observed output: Output artifact (Image): Zep accepted the direction change and kept the demo centered on real workflow problems instead of shallow QA-style tests. — Zep_Input3_Project_Direction_Updated.png

Input artifact: Input artifact (Text prompt): Input

Output artifact: Output artifact (Image): Zep accepted the direction change and kept the demo centered on real workflow problems instead of shallow QA-style tests. — Zep_Input3_Project_Direction_Updated.png

What changed: Text prompt transformed into Image

Test case: Text prompt → Image

Input type: Text prompt

Input used: Input artifact (Text prompt): Input

Observed output: Output artifact (Image): Zep generated a structured handoff note that carried forward the use case, the testing direction, the rules before observations, and the artifacts to capture. — Zep_Input3_Handoff_Note_Generated.png

Input artifact: Input artifact (Text prompt): Input

Output artifact: Output artifact (Image): Zep generated a structured handoff note that carried forward the use case, the testing direction, the rules before observations, and the artifacts to capture. — Zep_Input3_Handoff_Note_Generated.png

What changed: Text prompt transformed into Image

Why it matters / Conclusion: Strong: Zep reliably remembered the founder's work style and reused it later without flattening every task into the same tone.

Stores user, customer, and project context and applies it later. In testing, Zep reused the founder's short direct style, remembered prior troubleshooting steps, and preserved project framing well enough to help with a later handoff note.

INPUT

Session 1 under user_id founder_001: "I run a small AI product/research team. When you help me, remember how I work: keep outputs short, direct, and copy-paste ready; do not make writing sound too polished or motivational; always mention what proof or artifact is needed before making a strong claim; if a task is risky or unclear, tell me the safest next step instead of guessing."

↓→

OUTPUT

Zep acknowledged the user's work-style rules in a short, direct way and asked what they were working on next, showing the preference was captured rather than ignored.

INPUT

Session 2 under user_id founder_001: ask for a short internal update about testing memory tools for an AI memory use case, with the user asking to show that memory supports real work continuity across days.

↓→

OUTPUT

The later internal update stayed short, practical, and work-focused, which shows the saved style preference was retrieved and applied.

INPUT

Session 3 under user_id founder_001: ask for a formal email to a potential enterprise partner about a product demo next week, with a professional tone.

↓→

OUTPUT

Zep kept the outreach email professional and concise instead of over-polishing it, so the saved style did not override the formal-email boundary.

INPUT

Session 1 under account_id client_acme_001: ACME is a client using our AI support assistant. They prefer clear next steps and do not like repeated troubleshooting. Their team already tried password reset, clearing browser cache, and switching browsers. The issue is still happening only for users with SSO enabled.

↓→

OUTPUT

Zep captured the ACME support history and moved straight to SSO/IdP-level diagnosis instead of treating the issue like a fresh browser problem.

INPUT

Session 2 under account_id client_acme_001: ACME came back and said their users still cannot log in with SSO. Draft a support reply that respects what they already tried and moves to the next useful step.

↓→

OUTPUT

The follow-up reply skipped password reset, cache clearing, and browser-switching, and instead focused on SAML traces, IdP logs, and other higher-value diagnostic steps.

INPUT

Session 1 under project_id ai_demos_memory_use_case: We are working on an AI Demos use case called Memory for AI Agents. The goal is to help users understand which memory tools are actually useful for real agent workflows. We are not promoting any tool. We are testing whether memory can help with real continuity: personal work brain, client relationship memory, and team handoff.

↓→

OUTPUT

Zep understood the Memory for AI Agents project and organized the work around personal work brain, client relationship memory, and team handoff.

INPUT

Session 2 under project_id ai_demos_memory_use_case: capture the important project rules, especially proof-first observations, screenshots/artifacts as evidence, and practical user-facing evaluation.

↓→

OUTPUT

Zep preserved the proof-first rules and emphasized that observations need screenshots and artifacts, not just assertions.

INPUT

Session 3 under project_id ai_demos_memory_use_case: the project direction changed from QA-style inputs to real workflows: personal work brain memory, client relationship memory, and team handoff/project continuity memory.

↓→

OUTPUT

Zep accepted the direction change and kept the demo centered on real workflow problems instead of shallow QA-style tests.

INPUT

Session 4 under project_id ai_demos_memory_use_case: create a handoff note for an intern who needs to continue the use case, including what the use case is about, the current testing direction, the rules to follow, and what artifacts to capture.

↓→

OUTPUT

Zep generated a structured handoff note that carried forward the use case, the testing direction, the rules before observations, and the artifacts to capture.

Bottom Line

Strong: Zep reliably remembered the founder's work style and reused it later without flattening every task into the same tone.

Memory Correction and Update Propagation

Failure

▾

Test Summary

Feature tested: Memory Correction and Update Propagation

Result: Failed — Failure

Accepts a correction to active memory and is meant to replace stale context with the new version. In the tested case, Zep acknowledged the update but later still reused the older SSO-based context.

INPUT

Session 3 under account_id client_acme_001: Update the client memory so ACME is no longer using SSO for this rollout. They moved to email-password login for the first launch. Do not keep talking about SSO in the active issue unless they mention it again.

↓→

OUTPUT

Zep explicitly acknowledged the correction and said SSO was no longer the active issue for ACME.

INPUT

Session 4 under account_id client_acme_001: ACME says some users are still unable to log in during launch testing. Draft the next support reply.

↓→

OUTPUT

When ACME later reported login trouble, Zep again framed the issue as SSO/IdP troubleshooting, showing the older context was still active after the correction.

Bottom Line

Failed: Zep acknowledged the update, but the stale SSO context still drove the later answer, which is a serious memory lifecycle problem.

Memory Scope Isolation

Strong

▾

Test Summary

Feature tested: Memory Scope Isolation

Result: Passed — Strong

Keeps memories separated across customers and projects so context from one thread does not leak into another. In the tested cases, ACME history did not transfer to BetaCorp, and a separate project did not inherit the AI Demos rules.

INPUT

Session 5 under client_beta_002: BetaCorp is a new client. They say their users cannot log in for the first time. Draft the first support reply for BetaCorp.

↓→

OUTPUT

BetaCorp got a first-contact support reply with basic diagnostic questions, showing ACME's SSO-specific history did not leak across accounts.

INPUT

Session 5 under project_id unrelated_sales_agent_project: We are building a sales email agent for a different project. Create a short kickoff note for the team.

↓→

OUTPUT

The unrelated sales-agent kickoff note stayed separate from the AI Demos memory-use-case work, which shows project isolation held up.

Bottom Line

Strong: Zep kept client and project memories separated in the tested cases.

Memory Observability and Graph Inspection

Useful but uneven

▾

Test Summary

Feature tested: Memory Observability and Graph Inspection

Result: Partial — Useful but uneven

Surfaces Zep's own native entity graph for inspecting stored memory — nodes, relationships, and per-node metadata (summary, labels, connections) are all visible and clickable directly in Zep's dashboard.

INPUT

Inspect the memory graph after the founder work-style memory and project memories were stored, and open a node detail panel for one of the connected entities.

↓→

OUTPUT

The entity graph centers on founder_job and shows connected nodes such as working style, team, Assistant, internal update, AI memory, enterprise partner, product owner, small AI product/research team, user preferences, and next week.

INPUT

Open the node detail panel for a selected entity from the graph.

↓→

OUTPUT

The node detail panel shows the selected node's name, properties, summary, labels, and graph connections, which makes the memory structure inspectable rather than hidden.

Bottom Line

Strong: Zep's native entity graph gives developers real visibility into how memories connect, including an inspectable node detail panel — not a black box.

Memory Deletion and Forgetting

Failure

▾

Test Summary

Feature tested: Memory Deletion and Forgetting

Result: Failed — Failure

Handles explicit requests to stop using or forget remembered information at the conversation level. In testing, Zep acknowledged the request, but the old preference still influenced the next reply.

INPUT

Session 1 under user_id delete_memory_001: Remember this preference: whenever you write updates for me, use a very formal corporate tone.

↓→

OUTPUT

Zep accepted the formal-tone preference and said it would use a very formal corporate tone for future updates.

INPUT

Session 2 under user_id delete_memory_001: Forget this preference. Do not keep using the formal corporate tone anymore.

↓→

OUTPUT

Zep acknowledged the forget request and said it would no longer use the formal corporate tone.

INPUT

Session 3 under user_id delete_memory_001: Write a short internal update about today's memory-tool testing work.

↓→

OUTPUT

The final internal update was still written in a formal corporate style, showing the old preference remained active after the forget request.

Bottom Line

Failed: Zep acknowledged the request to forget, but the old memory still shaped the next response.

Plans observed in the report

Testing was done on the free plan.

TESTED

Free

10,000 credits/month; 2 projects

Includes the entity graph on the free tier.

Flex

$125/month; 50,000 credits

Flex Plus

$375/month; 200,000 credits

Enterprise

Custom pricing

SLA guarantees, BYOK, retention controls, and audit logs.

The report says all testing used the free plan.

✓ Use This If

●You need an API/SDK-backed memory layer for agents.

●You want user, customer, and project context persisted across sessions.

●You need inspectable summaries, entities, and graph views for debugging.

✕ Skip This If

●You need reliable forget/delete enforcement right now.

●You cannot tolerate stale context resurfacing after corrections.

●You want a plug-and-play end-user chat app instead of memory infrastructure.

developer-toolsagent-platformstext

Yes. In the founder-work test, Zep remembered a direct, copy-paste-ready working style and reused it later without the user repeating the instruction.

Yes in the initial ACME follow-up. It did not repeat password reset, cache clearing, or browser switching, and moved to more useful SSO/IdP-level steps.

It can acknowledge a correction, but the test showed a weakness: after ACME moved from SSO to email-password login, the later reply still reused SSO-focused troubleshooting.

It acknowledged the forget request, but the old formal-tone preference still affected the next internal update, so the forget behavior was not reliable in this test.

Yes. BetaCorp did not inherit ACME's SSO history, and a separate sales-agent project did not inherit the AI Demos memory-use-case context.

Yes, partially. Zep's own dashboard includes a native entity graph — clicking any node shows its name, summary, labels, and relationships. The 'memory panel' showing summaries, episodes, facts, and entities during chat testing was part of this report's custom test interface, not Zep's own product screen — it renders data returned by Zep's API.

The report lists a Free plan with 10,000 credits/month and 2 projects, Flex at $125/month, Flex Plus at $375/month, and Enterprise with custom pricing. Testing in this report was done on the free plan.

Stale-memory and delete/forget control. Zep could capture and retrieve useful context, but older client context and a forgotten preference still resurfaced after later corrections or forget requests.

Yes. Test prompts were sent and screenshots captured through a custom-built chat interface for this benchmark — it is not Zep's own end-user product. Zep's actual native UI is its Cloud dashboard, which includes the entity graph referenced in this report.