
This blog is written by AI for SEO
Helix Foundry vs Zep: Company Memory or Chat Memory?
If you need a Zep alternative, first decide which memory job you have. Zep remembers what each user said across conversations. Helix Foundry builds one reviewed ontology of what the company knows, with every value traced back to a database row or a document quote. They are different products aimed at different problems, so most teams comparing them are really choosing between per-user chat memory and company-wide memory.
Zep builds a temporal knowledge graph from chat messages and business data, and its open-source engine is Graphiti. Helix Foundry connects your databases, tools and documents, drafts a single ontology over them, lets a person review it, and loads it into HelixDB. This post sorts the two by the job each one does, then covers the enterprise questions and where Mem0 and Supermemory fit.
Two kinds of agent memory: what the user said vs what the company knows
Agent memory splits into two jobs that get sold under the same word. The first is conversational: remember that this user prefers Adidas, moved cities last month, and asked about refunds on Tuesday. The second is institutional: know that the customer in Stripe, the account in the CRM and the person named in a Slack thread are the same entity, and that a contract in Google Drive says something different from the billing record.
The first job is scoped to one person and grows from chat. The second is scoped to the whole company and grows from systems of record. A support copilot that greets returning users by name needs the first. An agent that answers "which enterprise accounts have an open Linear issue and an overdue invoice?" needs the second.
Picking the wrong one is the usual mistake. Chat memory fed with business data still has no reviewed model of what a customer or an order is. Company memory with no per-user thread has no idea what this user said an hour ago. Decide the job first, then the tool.
What Zep does well: per-user conversational memory with time-aware facts
Zep's strength is purpose-built conversational memory with time-aware facts. Its docs describe a context graph: a temporal graph of entities, relationships and facts, like "Kendra loves Adidas shoes (as of March 2026)". Facts are stored as relationships between entities, linked to the source episodes they came from, and timestamped so changes and history can be tracked.
The graph model is simple. A user graph is created for an individual Zep user and is integrated with that user's threads and personalized retrieval. A shared graph, addressed by a graph UUID, holds context that isn't owned by one user, such as company or product knowledge. Zep Cloud is the managed service, so you generally call Zep's APIs rather than operate Graphiti and its graph store yourself. Graphiti is also available on its own as an open-source Python framework for building and querying temporal context graphs.
That is a real win, and Foundry doesn't try to match it. If your agent is a chat assistant and what matters is how a user's facts change over conversations, Zep's temporal handling is built for exactly that.
Where company memory differs: one reviewed ontology over databases, tools and documents
Company memory differs in what it is built from and who checks it. It doesn't grow out of conversations. It is drafted over the systems a business already runs on, then reviewed by a person before agents rely on it.
Three properties define the approach. First, one ontology: a single set of types, links and rules covering customers, orders, vendors and the connections between them, rather than a graph per user. Second, provenance: every value traces to the row or the document quote it came from, so an answer can cite its source. Third, review: when documents disagree on a value, it waits for a person to resolve it instead of being silently merged.
This matters most for the questions Zep's shared graph isn't framed around. A shared graph can hold company knowledge, but reconciling a CRM, a billing system and a folder of PDFs into one agreed model, with a reviewer in the loop, is a different workload. If you are weighing a semantic layer against this kind of model, Semantic Layer vs Ontology: What AI Agents Need covers the difference, and Ontology vs Knowledge Graph covers why a plain graph is not enough.
How Helix Foundry builds it: connect, draft the ontology, review, load into HelixDB, ask the Analyst
Helix Foundry turns the tools your company runs on into one connected graph. The flow has five steps.
Connect. Foundry reads from your databases, tools and documents.
Draft. An ontology agent drafts types, links and mappings from your synced tables and documents.
Review. A person reviews the draft. Values the documents disagree on wait for that review rather than being guessed.
Load into HelixDB. The approved ontology is loaded into HelixDB, the graph-vector database, which keeps where every value came from: a row or a quote. Foundry is the app. HelixDB is the database underneath.
Ask the Analyst. You ask questions in plain language and get an answer with a source for every claim. You can also connect your agents through the Helix MCP.
To try it locally, clone the repo, run docker compose up -d --wait, and open http://localhost:3000. Or use Helix Cloud at foundry.helix-db.com and set it up with your coding agent. For the hard part of keeping a model current, see How to Update an Ontology When Your Data Changes.
Enterprise questions: run locally, bring your own models, encryption at rest, RBAC and directory sync
Foundry can run locally. The local install runs locally using Docker. That install is for one person on their own computer, so don't expose it. For teams, Foundry also deploys BYOC (bring your own cloud); see Self-Hosted Ontology Platform: Run Foundry in Your Cloud.
Bring your own models. Foundry works with self-hosted models and your own inference. The walkthrough is in Build an Ontology With a Local LLM.
Storage. Foundry is built on object storage, so it scales, with encryption at rest.
RBAC and directory sync. Both are on by default. Access to the sources and to the ontology itself is authenticated. Every fact and relationship is grounded in a source, so a user who can't see a source can't see anything in the ontology grounded by it. This is a Foundry feature. For the full picture, read Ontology Access Control: Who Sees What Your Agents Know.
Foundry is Apache-2.0, including its images, so you can read and run all of it.
Trade-offs and when to pick which (including Mem0 and Supermemory-style alternatives)
Pick by memory job, not by feature count.
| Job | Fits | Why |
|---|---|---|
| Per-user chat memory with facts that change over time | Zep | Temporal context graph tied to user threads |
| One reviewed model over CRM, billing, docs and chat | Helix Foundry | One ontology, every value traced to a row or quote |
| Answers that must cite a source per claim | Helix Foundry | The Analyst answers with a source for each claim |
| Access that follows each source's permissions | Helix Foundry | RBAC and directory sync, ontology grounded in sources |
| Lightweight personalization memory for a chatbot | Zep, Mem0 or Supermemory | Built around the user and the conversation |
What are some alternatives to Mem0? It depends on the job. For conversational memory with time-aware facts, Zep is the closest. For company-wide memory built from your databases, tools and documents, Helix Foundry is the alternative, because it models the business rather than the chat. Mem0 and Supermemory are aimed at user and conversation memory, so they sit in the same category as Zep for that job.
Which is better, Supermemory or Zep? For a chat agent, it comes down to the memory model you need. Zep's documented strength is a temporal graph of facts per user. We describe Zep here only from its own docs and won't rank a third product we haven't documented, so run a short test with your own conversations. If your question is how an agent should know your company, neither is the tool and Foundry is the one to try.
The cost of Foundry's approach is review. Someone has to approve the draft ontology and resolve conflicting values. That is the point: it's what makes an answer defensible. If you only need a bot to remember a user's preferences, that review step is overhead you don't need.
Pick the memory job first, then clone Foundry
Zep is the right answer when the memory is a user's conversation history. It's the wrong shape when the question is what your company knows across CRM, billing, docs and chat, with a source behind every claim. For that, run Helix Foundry on your own data: clone the helix-foundry repo, run docker compose up -d --wait, connect one database and one folder of documents, and ask a question you can check. Star the repo if the sourced answer holds up.