# kgai vs Mem0, Zep and Memov for a dev team's shared memory.

An honest comparison of shared memory for AI-assisted development. Four good tools that remember four different things. This page says plainly which is which, including what kgai does not do, so you can pick in ten minutes.

- **Canonical URL.** https://kgai.dev/compare
- **Facts sourced.** July 2026. Page last modified 2026-08-19.
- **Author.** kgai maintainers, team@kgai.dev
- **Home.** https://kgai.dev/
- **Source repo.** https://github.com/kgaidev/kgai

> We build kgai, so read accordingly. Every claim about the other tools comes from their public docs and repos. If we got something wrong, tell us at team@kgai.dev and we will fix it.

On this page: Ten seconds, Side by side, The others, Where kgai wins, Setup, Numbers, FAQ.

## 01. The ten-second version

**Different tools remember different things.**

None of these is a drop-in replacement for another. The real question is what you need remembered.

- **kgai. Your team's decisions.** Why the code is the way it is, what changed, the reasoning, and the alternatives you rejected. Shared by every dev and every AI on the team.
- **Mem0. Your users.** A memory layer that learns preferences and facts about a person across sessions, to personalize an assistant or app.
- **Zep / Graphiti. Facts over time.** A temporal knowledge graph built from your conversations and documents, with real time-validity on every fact.
- **Memov. Your sessions.** A git-like timeline of one developer's agent sessions, prompts, responses and diffs you can search and replay.

## 02. Side by side

**What each one is, underneath.**

| | kgai | Mem0 | Zep / Graphiti | Memov |
|---|---|---|---|---|
| **Unit of memory** | **A decision.** What changed, why, what was rejected, mutating a small graph of domain elements | Facts about a user, extracted from conversations | Entities and facts with validity windows, extracted from text | Session snapshots: prompt, response, plan, diff |
| **How it's captured** | **By the agent itself, during normal work.** A skill records, a hook catches what it forgot. No pipeline, no extra LLM calls | LLM extraction pipeline per exchange (add / update / delete) | LLM extraction pipeline per episode | Session recorder |
| **History** | **Immutable, append-only.** New decisions supersede old, dead ends stay queryable, `kg as-of` replays any past date | Reconciled. Memories are updated or deleted as facts change | Non-destructive. Contradicted facts are invalidated but kept | Immutable snapshots, rollback via branches |
| **Deterministic?** | **Yes.** Content-addressed events, deterministic ids. Every machine replays the log to a byte-identical graph, verifiable with `kg export --canonical` (sha256) | Extraction depends on the LLM run | Extraction depends on the LLM run | Snapshots are deterministic, per machine |
| **Team sync** | **Any S3 bucket you own.** Write-once per-writer shards, so parallel writers can't produce a textual conflict. Real contradictions surface as an explicit branch to resolve | Hosted platform, per-user / per-agent scoping | Runs as a service, team story via Zep Cloud | Per-repo timeline, no multi-writer merge story |
| **What you operate** | **Nothing.** Embedded engine in the plugin. No server, no database, no API key | Vector store plus LLM/embedding keys, or the hosted platform | Graph DB (Neo4j / FalkorDB) plus LLM calls, or Zep Cloud | Local tool plus MCP server |
| **Retrieval** | Lexical plus graph traversal. **No embeddings, by design.** The asking agent bridges synonyms by rephrasing | Semantic vector plus keyword hybrid, stronger fuzzy recall | Semantic, graph and keyword hybrid | Semantic search over session history |
| **Works with** | Claude Code plugin (automatic), any agent or script via the `kg` CLI, MCP endpoint in cloud beta | SDKs (Python/TS), MCP, many framework integrations | Python SDK, REST, MCP | MCP (Claude Code, Cursor, and others) |
| **Measured at scale** | **1,000,000 decisions / 30 writers:** ~100 ms decision lookups, byte-identical clones. [Numbers](https://kgai.dev/#scale) | Benchmarks target conversational recall (LoCoMo) | Benchmarks target conversational recall (DMR, LongMemEval) | n/a |
| **License** | MIT, local-first, hosted cloud in beta | Apache-2.0 plus hosted platform | Apache-2.0 engine plus Zep Cloud | MIT |

Sourced from each project's public README and docs, July 2026. Corrections welcome.

## 03. The wider field

**What about the others?**

The three columns above each stand for a whole category. If you're evaluating one of these, here's where it fits.

**Cognee.** Same category as Zep: builds a knowledge graph and vector index from your documents with an LLM pipeline. Strong at ingesting arbitrary content, same trade-offs on determinism and infrastructure.

**Letta (MemGPT), MemOS, Memobase.** Same category as Mem0: memory for an assistant or its users. Self-editing agent state, memory-OS research, user profiles. General agent memory, not a record of a team's engineering decisions.

**Claude-Mem.** A session recorder for Claude Code: compresses past sessions so the next one starts informed. A different job than a decision graph. Teams happily run it side by side with kgai.

**projectmem, CodeAlmanac.** Closest neighbours in spirit: dev-knowledge logs and repo wikis for coding agents. kgai differs on the deterministic graph, byte-identical replay and conflict-free team sync.

## 04. Where kgai wins

**Built for one job: a team that must not lose its why.**

Everything below follows from one design choice: memory as an immutable log of decisions instead of a mutable pile of extracted facts.

- **The why survives, verbatim.** Nothing is overwritten. New decisions supersede old ones, and "how did this get this way?" always has an exact, dated answer.
- **Dead ends are memory too.** Rejected approaches stay in the graph with the reason they died, so neither a new hire nor an AI re-walks a path the team already proved wrong.
- **Deterministic, verifiably.** No LLM in the storage path means the same log replays to the same graph on every teammate's machine. And you can check it: `kg export --canonical` digests match, sha256 for sha256, tested to a million decisions.
- **Sync without a server.** A bucket you own is the whole backend. Write-once shards make textual merge conflicts impossible by construction. Genuine contradictions become explicit branches, and the resolution is itself a recorded decision.
- **Remembering costs no tokens.** Capture rides the coding session your agent is already having. No extraction pipeline, no embedding bills, no background jobs.
- **Nothing to babysit.** No database to upgrade, no service to monitor, no API key to rotate. Local-first: reads and writes are instant and work offline.

## 05. The whole setup

**Six commands, lifetime total.**

Install, once. The prebuilt engine for Linux and macOS downloads itself. No Go, no compiler, no database.

```
claude plugin marketplace add kgaidev/kgai
claude plugin install kgai@kgai-marketplace
```

Team sync, once. Any S3-compatible bucket you own. No server, no accounts to manage, no lock-in.

```
kg init --remote s3://your-bucket/team-kg
kg sync
```

Every day, zero. Capture and recall are automatic in the session. Ask by hand anytime with `kg search` and `kg history`.

```
# nothing. your agent records
# and recalls on its own
```

## 06. Measured, not promised

**The claims above are tested numbers.**

- **1M / 30.** Decisions / concurrent writers in the largest archived run.
- **sha256 =.** Independent clones replay byte-identical, arrival order doesn't matter.
- **~100 ms.** Decision lookups and element history, flat to 1M.

The full latency table, including the slow paths we haven't fixed yet, is in the repository. Recall and free-text search are slower than decision lookups.

## 07. Fair questions

**Asked by people choosing.**

### Can I use kgai and Mem0 together?

Yes, and it can make sense: they don't overlap. Mem0 remembers who the user is. kgai remembers why the code is the way it is. An agent can read both.

### Zep also keeps history. How is kgai different?

Zep's temporal graph is genuinely good, and it's the closest tool to kgai on this axis. The difference is what goes in and how. Zep extracts facts from prose with an LLM, which is probabilistic and needs a graph database and extraction calls. kgai stores explicit decisions written by the agent as it works, deterministic, replayable, no infrastructure. Zep answers "what was true when". kgai answers "what did we decide, and why".

### What happens when two people decide the same thing differently?

Both decisions survive. Sync cannot lose either, by construction. The element shows up in `kg conflicts` as a branch with both heads, and anyone resolves it by recording one new decision that supersedes both. The branch and its resolution stay in history.

### What if kgai the project disappears?

Your store is an append-only NDJSON log of content-addressed events sitting in your repo, and in your bucket if you sync. It's plain text: readable, greppable and portable without our code. MIT-licensed engine, no hosted dependency in the free tier.

### Does kgai have vector or semantic search?

No, by design. kgai matches your words against element names and decision texts deterministically (word overlap), so the same store gives the same answer on every machine. The AI agent doing the asking bridges synonyms by rephrasing. If you need fuzzy semantic recall over large amounts of prose, Mem0 or Zep are stronger at that.

### What is the difference between kgai and Mem0?

Different units of memory. Mem0 extracts facts about a user from conversations with an LLM pipeline and reconciles them (memories can be updated or deleted). kgai records a team's engineering decisions, what changed, why, and what was rejected, as an immutable, content-addressed log that replays to a byte-identical graph on every machine. Mem0 personalizes assistants. kgai remembers why the code is the way it is.

### How does a team share one kgai memory?

`kg init --remote s3://your-bucket`, then `kg sync`. Every writer appends to their own write-once shard, so two people recording at the same time cannot produce a textual merge conflict. Genuinely contradictory decisions surface explicitly as a branch you resolve with one new decision. No server to run.

### Does kgai work outside Claude Code?

Automatic capture ships as a Claude Code plugin today. Any other agent or script can read and write the same store through the `kg` CLI (stable JSON output). An MCP endpoint, for access from Cursor, Windsurf, Codex and other MCP-capable agents, ships as part of kgai cloud, currently in beta.

## Get started

- Get started on GitHub: https://github.com/kgaidev/kgai
- See how kgai works: https://kgai.dev/

```
claude plugin marketplace add kgaidev/kgai
claude plugin install kgai@kgai-marketplace
```

---

kgai, an immutable memory of engineering decisions. Notes: https://kgai.dev/blog/ · Papers: https://kgai.dev/papers/ · GitHub: https://github.com/kgaidev/kgai · team@kgai.dev · MIT

This page was written and built with AI assistance.