OMEM vs Letta
Letta is an agent framework with memory. OMEM is memory for the agents you already have.
Letta (the MemGPT lineage) is an agent runtime where agents manage their own memory hierarchy. It answers the whole question of how to build an agent. OMEM answers one question extremely thoroughly: what does this agent believe, and why. It sits under whatever framework you already chose, through MCP, a REST API, or the SDK.
What Letta is genuinely good at
A comparison that cannot say this is an advertisement. These are real strengths, and if they match your problem, use Letta.
- The whole agent runtime
- Agents, tools, and self-editing memory in one system, from the team that started the MemGPT line of thinking. If you are starting fresh, that completeness is attractive.
- Self-editing memory hierarchy
- The core/archival memory design is a genuinely interesting answer to the context window problem.
- An opinionated, integrated stack
- Fewer decisions for you to make, because the framework made them.
What OMEM does differently
Every claim below is asserted by the repository's CI, so none of it can quietly stop being true.
- Belief state, not stored strings
- Every claim has a state (believed, contradicted, unknown) computed from the evidence at query time. Two agents asserting opposite things produces CONTRADICTED with both sides on the record, never a silent overwrite.
- Conflicts are declared, never guessed
- Two claims disagree only when someone declared them opposed. No model reads your memories to decide they conflict, which is what keeps the same question giving the same answer a year later.
- Answers for itself
- Ask why about any belief and get the evidence chain: who said it, the quoted source, what was concluded from it, what contradicts it. The whole state replays from an append-only log, and omem-verify proves it rather than claims it.
- Takes things back
- Retract a fact and everything concluded from it is withdrawn in the same request, cascade included. Declared inference rules come with truth maintenance built in.
- Hunches that know they are hunches
- The intuition layer forms expectations from single examples, keeps a case file per hypothesis, interrogates its own guesses, and never lets a hunch pass as a belief. expects() and believes() are different verbs.
- Zero dependencies, committed license
- Stdlib-only Python (CI fails the build if a runtime dependency appears), SQLite by default, runs air-gapped. MIT, with a written commitment in CONTRIBUTING.md that the core stays MIT.
mem.remember(agent="sales", about="customer:acme", claim="prefers_annual_billing")
mem.remember(agent="support", about="customer:acme", claim="not:prefers_annual_billing")
mem.believes(about="customer:acme", claim="prefers_annual_billing")
# -> CONTRADICTED (both sides on the record, neither silently wins)
mem.why(assertion_id)
# -> the evidence chain: who said it, the quoted source, what conflicts
The honest decision guide
Choose Letta when
- You are starting from zero and want the framework and the memory as one decision
- Agents editing their own memory is the behaviour you want
- You are comfortable inside one integrated stack
Choose OMEM when
- You already have an agent stack (LangGraph, Claude via MCP, your own) and need the belief layer under it
- Memory must survive audits: evidence chains, declared conflicts, replayable history
- You want the memory to be framework-agnostic so the stack can change without losing the record
- The intuition loop matters: hypotheses with case files, interrogation, calibration