Both are temporal graphs. The source is what differs.
Zep builds a temporal context graph from your agent's conversations and user interactions. HangarX Cortex builds a knowledge graph from your existing corpus — documents, notes, code, design docs — and exposes it via MCP to every AI tool you use.
Both are excellent. Both are temporal-aware. They're solving different memory problems.
Pick Cortex if
Your agent's memory should come from documents you already have.
Knowledge bases, technical docs, Obsidian vaults, codebases, meeting notes — anywhere structured truth lives in writing. Cited claims, MCP-native, self-hostable.
Pick Zep if
Your agent's memory should come from interactions with users.
Customer-facing assistants, healthcare, CRM, support agents. Excellent SDK ergonomics, enterprise compliance posture, and a temporal-graph engine purpose-built for this.
What we agree on
Cortex and Zep are architecturally closer than most other tools in this space. We agree on the fundamentals.
- Knowledge graphs beat flat memory — entities and relationships unlock multi-hop reasoning
- Temporal awareness matters — facts have validity ranges; agents need to reason about 'as of when?'
- Hybrid retrieval beats pure vector — both blend keyword, vector, and graph traversal
- Open source contribution — both teams ship serious OSS (Graphiti, Cortex API)
- Multi-LLM — neither locks you into a single provider
- Production-ready — both ship in real products with enterprise customers
Where we differ
The dimensions that matter when both products have a temporal knowledge graph but different sources of truth.
| Dimension | HangarX Cortex | Zep |
|---|---|---|
| Primary memory source | Existing corpus (documents, notes, code, URLs) | Conversations + user interactions + business events |
| Temporal knowledge graph Both support temporal claims with validity ranges. Zep's Graphiti is purpose-built for this; Cortex supports asOf queries across the claim graph. | ||
| Open-source graph engine Cortex uses FalkorDB (Cypher-compatible). Zep open-sourced Graphiti as a standalone Python library. | ||
| Self-host the full platform Graphiti is open source as a library, but the Zep platform is managed-only. Cortex ships a Docker Compose stack that runs anywhere — laptop, VPC, air-gapped. | ||
| 100% local mode (no cloud) | ||
| MCP server (cross-tool memory) Cortex is MCP-native — Claude, Cursor, Cline, Windsurf all read the same memory through it. Zep doesn't currently expose an MCP server. | ||
| Document ingestion pipeline Zep ingests documents but is optimized for chat + business events. Cortex is built around corpus ingestion as the primary path. | ||
| Claims with provenance (SPO triples) | ||
| Contradiction detection across claims Zep's temporal graph invalidates outdated facts. Cortex surfaces contradictions across claims for auditability. | ||
| Hybrid retrieval (BM25 + vector + graph) | ||
| Native Obsidian plugin | ||
| Multi-LLM provider support | 8+ providers | Multiple via OpenAI-compatible endpoints |
| SDK languages | TypeScript / REST / MCP | Python, TypeScript, Go |
| SOC2 / HIPAA compliance Zep is enterprise-compliance-forward. Cortex Cloud is moving in that direction; for compliance-strict workloads, the local Docker stack lets you operate inside your own compliant environment. |
The wedge
Zep's engineering is excellent. Graphiti is one of the most thoughtful open-source temporal knowledge graphs shipped to date, and the platform is the right answer when you're building a user-facing agent that learns about each user through conversation.
But not every agent is user-facing, and not every memory comes from a conversation. A growing class of agents — coding copilots, research assistants, internal-search agents, documentation-grounded support bots — needs memory that's rooted in a corpus you've already authored. Specs, runbooks, design decisions, codebase comments, postmortems, meeting notes. That memory exists today; the job is to extract, structure, and serve it.
Cortex is built for that workload. Corpus ingestion as the primary path. SPO claims with provenance so every retrieved fact links to a source span. MCP-native serving so the same memory plugs into every AI tool on a developer's machine. Self-hostable so it works in regulated environments where managed-only isn't an option.
When you should pick Zep
- You're building a customer-facing agent that needs to remember user preferences, history, and context across sessions.
- Your memory source is conversations and user interactions, not a pre-existing knowledge corpus.
- You need SOC2 / HIPAA compliance posture today, on managed infrastructure.
- Your team prefers Python or Go SDKs and wants 3-line agent integration with no extra plumbing.
- You want a managed cloud platform with enterprise-grade SLAs and global infrastructure.
- You specifically value Graphiti's temporal-graph design — it's a research-quality contribution and the right primitive for chat-history workloads.
When you should pick Cortex
- Your agent's memory should come from documents, notes, codebases, or other written corpora — not from conversation history.
- You want every retrieved claim to link back to a verifiable source span. Provenance is first-class, not bolted on.
- You need the same memory exposed to multiple AI tools (Claude Desktop, Cursor, Cline, Windsurf, Zed) over MCP — Cortex is MCP-native; Zep currently requires SDK integration.
- You need to self-host the entire stack — laptop, VPC, or air-gapped — not just an open-source library.
- You're an Obsidian user. Cortex has a native plugin; Zep doesn't.
- You want auditable memory: contradictions surfaced, claims cited, temporal queries supported via asOf — and the data living in transparent stores you can query directly.
FAQ
Cortex and Zep both have temporal knowledge graphs. What's actually different?
The source of truth. Zep's graph is built from conversations, user interactions, and business events flowing through your agent. Cortex's graph is built from your existing corpus — documents, notes, codebases, design docs — and exposes that as memory. If your memory needs to come from interactions, Zep. If it needs to come from sources you've already authored, Cortex. Both are temporal-aware.
But Graphiti is open source — can't I self-host Zep?
You can self-host Graphiti (the temporal-graph library), but the full Zep platform — the API, retrieval pipeline, and serving layer — is managed-only. Cortex's full stack is self-hostable in Docker. If your team needs to run memory infrastructure inside your own VPC or air-gapped, Cortex is the closer fit. If you're happy on a managed cloud, Zep's developer ergonomics are excellent.
Can I use both?
Yes. Some teams use Zep for conversational memory (the user history layer) and Cortex for corpus-grounded memory (the knowledge layer). Both can be exposed to the same agent — Zep via SDK, Cortex via MCP. They cover different memory dimensions.
Why does MCP matter?
MCP (Model Context Protocol) is the open standard for connecting AI tools to external memory and capabilities. Cortex exposes an MCP server, so any MCP-compatible agent (Claude Desktop, Claude Code, Cursor, Cline, Windsurf, Zed, Goose) can read the same memory without per-tool integrations. Zep currently requires an SDK in your agent code. If you're building a custom agent, that's fine. If you want to plug into existing agent harnesses, MCP-native matters.
Is Cortex open source?
Yes. The Cortex API stack and the Obsidian plugin are open source. Cloud mode runs the same core with managed infrastructure on top. Zep open-sourced Graphiti (the temporal-graph library) but not the full platform. Both teams have made meaningful OSS contributions.
Related comparisons
If you're evaluating this against Cortex, you're probably also weighing these.
Memory from your corpus, not your conversations.
Point Cortex at your docs, notes, or codebase. Watch your agents start citing them — over MCP, across every AI tool you use, with full provenance.