Compare
Milestone vs Zep
Zep is a context-engineering platform for AI agents, built on Graphiti - an open-source temporal knowledge graph engine that tracks not just facts but when each fact started and stopped being true. Milestone is also built on a knowledge graph, but it isn’t an engine you build on: it’s a team workspace where the graph fills itself from the work, and agents read it over MCP. Two graphs, two very different jobs.
Updated August 3, 2026
The short version
Zep is the better choice if you are building an agent and want a temporal graph you can own, self-host, and query on your own terms - its point-in-time reasoning is more sophisticated than anything Milestone claims. Milestone is the better choice if you don’t want to build an application at all: you want your team’s decisions and conventions to accumulate on their own and show up in every agent session, with a human review step before they do.
At a glance
| Milestone | Zep / Graphiti | |
|---|---|---|
| What it is | A team workspace and tracker built on a typed knowledge graph | A temporal knowledge graph engine (Graphiti) plus a hosted context platform |
| Who it's for | Teams that use AI coding agents | Developers building agents and AI applications |
| Do you build anything? | No - install the app and connect your agent | Yes - Graphiti is a library; you build the app around it |
| Graph model | Typed domain nodes - tasks, decisions, conventions, gotchas, people, code areas | Entities and relationships extracted from the data you ingest |
| Time model | Recall windows by plan; supersession handled through review | Bi-temporal - tracks when a fact held and when it stopped |
| Where the data comes from | The work itself - tasks, decisions, reviewed learnings | Whatever you ingest: chat, documents, business data |
| Quality control | New learnings stage in /context and are approved before they stick | Automatic extraction; you own any review layer |
| Agent access | MCP, with write-back, plus Claude Code sessions run in-app | SDK and API, plus a Graphiti MCP server for MCP-compatible clients |
| Self-hosting | No - hosted on AWS (US), cached locally so the app works offline | Yes - Graphiti is Apache 2.0 and self-hostable, or use hosted Zep |
| Pricing | Free forever + Pro $12/seat/mo (free during early access) | Free tier plus paid plans metered on usage; OSS core is free* |
* Milestone pricing shown in full. Zep’s hosted tiers are metered and change periodically - see getzep.com/pricing for current rates. Graphiti itself is Apache 2.0 and free to self-host, at the cost of running the graph database behind it.
Both are knowledge graphs. Only one of them ships an app.
This is the difference that actually decides it. Graphiti is a library: you ingest data, it extracts entities and relationships, and you build the product experience yourself - the interface, the capture flow, the permissions, the review. Milestone starts from the other end. The app is the tracker your team already needs, and the graph is what the tracker produces. Nobody sits down to “populate the knowledge graph”; they plan work, make decisions, and close tasks, and the graph is the residue.
Extracted entities vs typed domain nodes
Graphiti’s graph is general-purpose by design - it will model whatever you feed it, which is exactly right for an engine meant to serve many domains. Milestone’s node types are fixed and opinionated: task, decision, convention, pattern, gotcha, preference, person, code area. Narrower, and deliberately so. Because the types are known, retrieval can be specific in a way a general graph can’t: an agent touching a file can ask for the conventions and known gotchas for that area, not just semantically similar nodes.
Where Zep is genuinely ahead: time
Graphiti’s bi-temporal model tracks when a fact became true and when it stopped, so you can ask what your system believed at a particular moment and watch beliefs supersede each other. That is real engineering and Milestone does not match it. Milestone handles staleness differently and more bluntly: learnings are reviewed before they become durable, superseded conventions get replaced rather than versioned, and recall windows are set by plan. If point-in-time reasoning over an evolving fact base is your requirement, use Zep.
Team-shared by default, with a gate
Because Zep is infrastructure, questions like “who can write to this graph,” “whose memory is this,” and “what happens when the model infers something wrong” are yours to answer. Milestone answers them for you: knowledge is scoped to a team, workspace, board, or person; team scope is the default; and anything an agent learns lands in /context for a human to approve before every future session starts inheriting it. Opinionated answers are a feature if they match your situation and a constraint if they don’t.
Where Zep is the better choice
Choose Zep or Graphiti if you are building software rather than running a team: you get an Apache 2.0 core you can read and fork, self-hosting on a graph database you control, temporal reasoning Milestone doesn’t offer, and no dependency on a pre-1.0 macOS app. Milestone is early - macOS only for now, hosted rather than self-hostable, and with no public SDK. If any of those are hard requirements, this isn’t a close call.
Can you use both?
Yes, and it’s a sensible pairing. They aren’t substitutes: Graphiti gives the agent you are building a memory of its own domain, while Milestone gives the team building it a shared memory of their decisions and conventions. Both expose themselves over MCP, so an agent can hold connections to each without either knowing about the other.
Who each is for
Choose Milestone if…
- You want a product, not a library to build on
- The knowledge you care about is created by your team's work, not ingested
- You want a human review step before agent-learned facts become team truth
- Typed conventions and gotchas beat general-purpose entities for your case
Stick with Zep / Graphiti if…
- You're building an agent or application, not adopting a workspace
- You need point-in-time reasoning over facts that change
- You want an open-source core you can self-host and fork
- You need to ingest arbitrary data - chat, docs, business records
Moving from Zep / Graphiti
There is nothing to migrate in the usual sense: Graphiti holds data your own application put there, and Milestone doesn’t import graphs. If you built on Zep to give a product memory, keep it. What Milestone would replace is the tracker your team plans in and the context you hand-feed into agent sessions - it imports tasks and projects from Linear, Notion, and Jira. Easiest start: run Milestone on your next new project, where there is no migration at all.
Questions
- Is Milestone an alternative to Zep or Graphiti?
- Only in the loosest sense. Zep and Graphiti are developer infrastructure: a temporal knowledge graph engine you build an application on top of. Milestone is the application - a team workspace where the graph fills itself from tracked work and agents read it over MCP. If you're writing code against a memory layer, Zep is what you want. If you want your team's decisions and conventions to reach every agent session without anyone building that, Milestone is aimed at that.
- Both use knowledge graphs. What's actually different?
- What's in the graph and who fills it. Graphiti extracts general entities and relationships from data you ingest, and models time bi-temporally - it tracks when a fact held and when it stopped. Milestone's node types are fixed and domain-specific: tasks, decisions, conventions, patterns, gotchas, people, and code areas, created as a byproduct of the team's work. Graphiti is more powerful and more general; Milestone is narrower and requires no integration work.
- Does Zep have better temporal reasoning than Milestone?
- Yes. Graphiti's bi-temporal model tracks the validity window of every fact, so you can reconstruct what the system believed at a point in time. Milestone doesn't do that. It handles staleness by staging agent-learned facts for human review before they become durable, replacing superseded conventions rather than versioning them, and applying plan-based recall windows. If point-in-time reasoning matters to you, Zep is the stronger tool.
- Can Milestone be self-hosted like Graphiti?
- No. Graphiti is Apache 2.0 and can be self-hosted on your own graph database, and Zep offers a community edition. Milestone is hosted: your graph lives on Milestone's servers on AWS in the US, encrypted in transit and at rest, with a local cache on your device so the app works offline. If self-hosting is a requirement, Graphiti is the right answer.
- Can I use Zep and Milestone together?
- Yes, and they don't overlap. Zep or Graphiti gives the product you're building a memory of its own domain; Milestone gives the team building it a shared memory of their decisions, conventions, and gotchas. Both are reachable over MCP, so a coding agent can connect to each independently.
Related comparisons
See it on your own project.
Join the design-partner program - free during early access, and we’ll set the MCP connection up with you.
Free during the design partner program · no card required · we only email you about early access.