The conversation around agent memory has evolved rapidly. A year ago, most teams were satisfied with simple vector stores. Today, they're asking harder questions: How do I model relationships? How do I track what changed over time? How do I connect conversations to structured business data?
Enter the next generation of memory platforms — systems built around temporal knowledge graphs and semantic understanding. Two platforms leading this charge are Zep and Graphlit, each with distinct approaches to solving the same fundamental problem: giving agents memory that actually thinks.
In this article, we'll compare these two platforms in depth — examining their memory models, ingestion capabilities, search infrastructure, and developer experience. Whether you're building conversational agents, autonomous assistants, or internal knowledge systems, this guide will help you choose the right foundation.
TL;DR — Quick Feature Comparison
Understanding the Platforms
What is Zep?
Zep is a context-engineering platform built for AI agents that need to remember. It constructs a living, temporal knowledge graph from conversations and structured data — tracking not just what was said, but when it was said and how the information evolved over time.
Under the hood, Zep uses a bi-temporal graph engine (built on the open-source Graphiti framework) that stores both event time and ingestion time. This allows agents to answer questions like "What did we discuss last Tuesday?" or "What changed since our last conversation?" with precision.
Zep Cloud is a fully managed service with performance guarantees and sub-200ms retrieval. Zep OSS lets you self-host for maximum control.
What is Graphlit?
Graphlit is a cloud-native semantic memory platform designed to give agents persistent, structured memory across all their data sources. It's built for multimodal ingestion — handling documents, audio, video, images, and conversations — and automatically extracts entities, relationships, and temporal context.
Where Zep focuses on conversation-first memory with temporal precision, Graphlit takes a broader view: memory as a unified layer across all your agent's knowledge sources. Every piece of content is parsed, enriched, and linked into a per-user knowledge graph that agents can search semantically, traverse contextually, and reason over relationally.
If Zep is optimized for conversation memory, Graphlit is built for comprehensive semantic infrastructure.
Ingestion Capabilities
Zep centers ingestion on conversation transcripts and structured business data. Developers ingest "episodes" — typically chat messages, meeting notes, or business events — which Zep processes into its temporal graph. This works well for conversational agents but requires custom pipelines for non-chat data sources.
Graphlit shines in data ingestion breadth, with 30+ pre-built connectors for:
- Communication platforms (Slack, Discord, email)
- Development tools (GitHub, Jira, Linear)
- Content sources (RSS, YouTube, web pages)
- Documents (PDF, DOCX, presentations)
- Media (audio with transcription, images with OCR, video)
Graphlit continuously polls or uses webhooks to sync new data, extracting entities, relations, transcriptions, and summaries automatically. This "bring all your data" philosophy means agents have unified memory across every information source — not just conversations.
Search and Retrieval Differences
Zep offers advanced hybrid retrieval over its temporal knowledge graph:
- Vector similarity search
- BM25 keyword search
- Graph traversal for relationship-aware retrieval
- LLM-augmented query expansion
- Sub-200ms retrieval at scale
Zep's strength is in precise temporal queries: "What did Alice say about the roadmap before the product launch?" The bi-temporal model makes this natural.
Graphlit provides smart hybrid retrieval combining:
- Vector semantic search
- Keyword search with ranking
- Graph-aware context expansion
- Entity-based filters ("Find content where Alice discussed pricing")
- Metadata filters (time, type, source, user)
Graphlit's retrieval is more semantically expressive across diverse content types. It's not just about conversation memory — it's about connecting ideas across documents, meetings, code, and communication in one unified search.
Memory Modeling: Temporal vs. Semantic
This is where the platforms diverge philosophically:
Zep uses a bi-temporal knowledge graph where each fact tracks:
- Event time (when it actually happened)
- Ingestion time (when the system learned about it)
Edges can be invalidated over time as new information arrives, creating a graph that evolves with truth. This is powerful for agents that need to understand "what was true then" vs. "what's true now."
Graphlit uses a semantic memory model focused on:
- Persistent entities and relationships
- Per-user knowledge graphs
- Content lineage and citations
- Temporal metadata (but not bi-temporal precision)
Graphlit abstracts away bi-temporal complexity in favor of breadth and semantic richness. The trade-off: slightly less temporal precision, but broader coverage across content types and sources.
Developer Experience and APIs
Zep is available as:
- Zep Cloud: Fully managed with SLAs, dashboard, and performance guarantees
- Zep OSS: Self-hosted with the Graphiti framework
SDKs are available for Python, TypeScript, and Go. The API surface is conversation-centric, with endpoints for adding messages, querying memory, and managing users. Documentation is solid, and the managed service removes infrastructure concerns.
Graphlit offers:
- One unified API for ingestion, query, and chat
- SDKs for Python, JavaScript/TypeScript, and C#
- UI dashboard for monitoring and testing
- Integration with agent frameworks via MCP (Model Context Protocol)
- Fully managed, auto-scaling infrastructure
Graphlit is built for teams who want production-ready memory without DevOps overhead. The broader API surface reflects its wider scope — not just conversations, but all content types.
Deployment and Operations
Zep Cloud handles all infrastructure, scaling, and maintenance. For teams that want control, Zep OSS requires hosting a graph database (Neo4j, Falkor, or Neptune) plus a search index (OpenSearch or similar) plus LLM infrastructure.
Graphlit is cloud-native only — no self-hosting option. This is a deliberate choice: we handle scalability and uptime so you can focus on building agents. For teams that need on-premise deployment, this is a limitation.
Use Cases: When to Choose Each
Choose Zep if:
- You're building conversation-heavy agents (chatbots, support assistants)
- You need precise temporal tracking ("what changed since last week?")
- You want the option to self-host with full control
- Your memory needs center on chat transcripts and structured events
Choose Graphlit if:
- You're building agents that live across multiple data sources
- You need multimodal ingestion (audio, video, documents, feeds)
- You want turnkey integration with 30+ platforms
- You need entity-aware, graph-enriched semantic search
- You prefer managed infrastructure
- Your agents need to connect ideas across formats and sources
Final Verdict: Different Tools for Different Contexts
Zep is an excellent choice for teams focused on conversational memory with temporal precision. Its bi-temporal model and sub-200ms retrieval make it ideal for chat-heavy applications where understanding time and change matters deeply.
But as agents become more autonomous and operate across diverse data sources — Slack threads, GitHub issues, meeting recordings, documentation, customer data — teams need memory infrastructure that goes beyond conversations.
That's why we built Graphlit.
With native multimodal support, 30+ connectors, entity-aware search, and a semantic knowledge graph that spans all content types, Graphlit provides the comprehensive memory layer that production agents need. We abstract away the complexity of bi-temporal modeling in favor of breadth, developer experience, and turnkey integration.
Both platforms represent the cutting edge of agent memory. The right choice depends on whether you're optimizing for conversation depth (Zep) or comprehensive semantic infrastructure (Graphlit).
Explore more:
Your agent deserves more than storage. It deserves a memory that understands.