← Home

Benchmark

Public, evidence-based comparison of AI agent memory infrastructure. Every claim is verified against official documentation.

Source review baseline: June 2026; claim-level source and access dates retained internally.

Feature Comparison

Encryption at Rest

SL✅
M0⚠️
Zep✅
LM❌
pgv—

Trust Quotient

SL✅
M0❌
Zep❌
LM❌
pgv❌

Cross-Agent Memory

SL✅
M0⚠️
Zep⚠️
LM❌
pgv❌

MCP Native

SL✅
M0✅
Zep⚠️
LM❌
pgv❌

Audit Trail

SL✅
M0⚠️
Zep✅
LM❌
pgv❌

Designed for LGPD/GDPR

SL✅
M0⚠️
Zep✅
LM❌
pgv❌

Neural Handover

SL✅
M0❌
Zep❌
LM❌
pgv❌

Open Source

SL✅
M0✅
Zep✅
LM✅
pgv✅

TypeScript SDK

SL✅
M0✅
Zep✅
LM❌
pgv—

Python SDK

SL✅
M0✅
Zep✅
LM✅
pgv—

Recall Latency P95

SL⚠️
M0?
Zep?
LM?
pgv?
✅ Documented in public sources⚠️ Partial / not clearly documented❌ Absent from public docs— Not applicable / not evaluated? Not publicly verifiable

Compared against features publicly documented by each provider at the time of source review. "Roadmap" = not yet GA; "—" = absent or not documented; "?" = not publicly verifiable. See /benchmark for full evidence and sources. Source review baseline: June 2026.

Sources & Notes

  • Encryption at Rest: Synapse: server-side AES-256-GCM with per-operation random IV and 128-bit GCM tag. Mem0: encryption documented for the cloud service, no per-memory scheme published. Zep: BYOK with AWS KMS. LangMem: library-only, no built-in encryption. pgvector: a Postgres extension, not agent-memory infrastructure — encryption depends on the host database.
  • Trust Quotient: Per-memory confidence score (0.0–1.0) computed server-side. Each recall result includes TQ for governance. Provided by Synapse Layer.
  • Cross-Agent Memory: Synapse: native cross-agent recall with TQ scoring. Mem0/Zep: achievable but not a dedicated documented feature. LangMem: library, requires custom implementation. pgvector: extension, not agent-memory infrastructure.
  • MCP Native: Synapse: MCP server with 13 tools. Mem0: official MCP server (mcp.mem0.ai). Zep: MCP via Graphiti, documented as experimental. LangMem: library, no MCP server. pgvector: none.
  • Audit Trail: Synapse: handover + operation logging. Mem0: cloud-only, limited documentation. Zep: comprehensive audit + API logging with SOC 2 Type II. LangMem: library, no audit. pgvector: none.
  • Designed for LGPD/GDPR: Synapse: designed for alignment (not a compliance certification). Mem0: mentions compliance frameworks (GDPR/CCPA). Zep: SOC 2 Type II + HIPAA BAA. LangMem: library, N/A. pgvector: none.
  • Neural Handover: Neural Handover: AES-256-GCM encrypted context transfer with single-use SHA-256 tokens and audit logging. Provided by Synapse Layer.
  • Open Source: All five have open-source components. Synapse: Apache-2.0. Mem0: Apache-2.0. Zep: Graphiti is open-source. LangMem: MIT. pgvector: open-source Postgres extension (PostgreSQL License).
  • TypeScript SDK: LangMem is Python/LangGraph only as of the source review. pgvector: a database extension, not an SDK — accessed via the Postgres client of the host language.
  • Python SDK: pgvector: a database extension, not an SDK.
  • Recall Latency P95: Synapse: <50ms is an internal target, not yet publicly benchmarked. Others: not publicly documented with P95 benchmarks.
  • Methodology: All claims verified against official documentation, public GitHub repositories, and published security audits as of June 2026. This comparison is maintained by the Synapse Layer team. If you believe any data point is inaccurate, contact us.
  • References: Mem0 Docs · Zep Docs · LangMem GitHub · Synapse Layer Docs

Why Trust Quotient Matters

The Problem

Long-running agents accumulate contradictory memories. A user says "I prefer Python" in January and "I'm switching to Rust" in March. Without a reliability signal, the agent treats both as equally valid — leading to incoherent responses, wasted tokens on stale context, and declining user trust.

The Solution

Trust Quotient (TQ) is a per-memory confidence score from 0.0 to 1.0 — computed server-side from content density, semantic coherence, and recency. Every recall result includes its TQ score, so your agent can prioritize high-confidence memories and discard noise programmatically — fewer tokens in, better decisions out.

The Result

Agents that improve with time instead of degrading. Trust Quotient creates a natural selection pressure on memory quality: high-TQ memories surface first, low-TQ noise is filtered. The longer an agent runs, the more reliable its context becomes. This is the opposite of what happens with flat memory stores — and the core reason Synapse Layer exists.

Key Differentiators

Trust Quotient

Synapse Layer provides per-memory Trust Quotient scoring for recall governance. Each result includes a TQ score for programmatic governance and noise control.

Native Cross-Agent Memory

Purpose-built for multi-agent systems. One agent stores, another recalls — with full attribution and TQ scoring.

Neural Handover

Encrypted context transfer with single-use SHA-256 tokens and full audit trail.

Try It Yourself

Run the cookbook examples and see the difference Trust Quotient makes.

View CookbookAPI DocsStart Free ↗