Zep builds context from your data.
memco builds learning from your work.

01The difference

• What it remembers

  Zep

  Facts and relationships from conversations and business data, with time.

  memco

  What agents learned doing the work.

• What improves over time

  Zep

  The context assembled for a request.

  memco

  Behavior on the next task, measured.

• Who learns from whom

  Zep

  Per user or per graph.

  memco

  Everyone in the network.

02Honest overlap

Where the products genuinely overlap.

Zep’s center of gravity is temporal context and contradiction-aware history. The overlap below is genuine — which is why the proof object on this page has to be different: a prior insight improving later work across people and tools.

1. Both products persist structured memory across sessions.
2. Both preserve provenance for what they store.
3. Both support scoped access to memory.
4. Both connect memory to agent surfaces, including MCP paths for coding-agent clients.

03Where each product starts

Different centers of gravity.

Zep models changing context. memco productizes how real work becomes reusable team learning.

• Zep · temporal context graphs

  Serve current and historical context about users, businesses, entities and events.

  • Primary inputs: chat, text, JSON, business events and agent activity represented as Episodes.
  • Outcome: the agent receives a governed account of what is true now and what was true before.

• memco · engineering learning

  Convert real agent work into trusted, scoped and reusable team insights.

  • Primary inputs: agent attempts, human corrections, failed paths, tests, review decisions, accepted fixes and downstream outcomes, according to released integration behavior.
  • Outcome: the later engineering run receives an evidence-backed action that avoids a previously failed path.

04The same week, replayed

One payment-retry bug. Two product jobs.

Illustrative engineering workflow — not customer evidence. The same scenario runs on every comparison page, so what differs is the product job, not the anecdote.

1. Agent A · Cursorpayment-retry taskcalls a helper that was retired last quarter
2. Failed testci · redthe dead end costs the run its first hour
3. Senior correctionreview + passing PRthe durable fact: which path works now, and why
4. Scoped trusted insightteam scope · provenance keptsource, contributor, scope and outcome attached
5. Agent B · Claude Codenext week · different personstarts ahead of the dead end

• What they can represent

  Zep can represent the helper, the source events, the change in validity and when the old pattern stopped being current.

• What memco makes of it

  memco focuses the reusable object on the action, source, scope, trust and later engineering outcome, then tests whether another agent avoided the old helper.

INSIGHT MEM-4821
ACTION  use retry_payment_v2
AVOID   legacy_retry
SCOPE   payments-service / Payments team
SOURCE  corrected PR + passing integration test
STATE   trusted
PROOF   later task avoided the retired helper

05Practical comparison

Dimension by dimension, in words.

Rows, not scoreboards: each dimension states what each product actually does, so the difference survives scrutiny.

Scroll sideways →

06Choose honestly

Two good answers to two different questions.

• Choose Zep if

  • ‘What was true at that time?’ is a first-class product requirement.
  • Production agents need temporal user, account or business context.
  • Episodes, validity windows, Context Graphs and Observations are the desired substrate.
  • Broad governed context infrastructure is the primary buying job.

• Choose memco if

  • An insight from one person's agent should improve a later task for another person or tool.
  • Corrections, failed paths and accepted outcomes keep getting rediscovered.
  • Shared learning needs source, standing, governance and a path to correction or retirement.
  • The learning should survive model, IDE and agent-platform changes.

07For your customers

If you are building memory into a product

• Zep SDK

  A context-engineering layer per user: your application feeds it data and retrieves a graph-backed context block.

• memco SDK

  A memory network per customer, learning from their agents' work, seeded from yours, metered by use.

  Build with the memco SDK →

08Proof, not vibes

The reuse test.

Do not stop at “the agent remembered.” If the main job is serving current and historical context about users, businesses, entities and events, evaluate Zep. If the job is to make real engineering learning travel across people and tools, run the memco reuse test.

1. Pick one repository and one repeated failure, correction or convention.
2. Record the baseline behavior without the shared insight.
3. Let Agent A hit the problem and capture the source-backed correction.
4. Review and scope the candidate insight using the product states actually available.
5. Give Agent B a related task in another session or tool.
6. Measure repeated-error rate, completion, agent steps, review corrections and source/scope integrity.
7. Record whether the insight helped, conflicted or should be corrected or retired.

A signup is not activation. Activation is an insight contributed from one task and correctly reused on a later task.

Run the reuse test →Read the research →

09Questions

What evaluating teams ask.