Compare · V1.0 · 2026-10-06
AirMemo and the memory tools
Mem0 and Letta (the project that grew out of the MemGPT research paper) are the two tools an agent team is most likely to already be running. Both are good, both are open, and both answer a different question than AirMemo does.
The difference is one sentence: a memory tool stores what an agent has been told; AirMemo decides what an agent is told next, and proves it. Memory is a store. AirMemo is a delivery layer.
What the memory tools do
Mem0 calls itself "the fully managed memory layer for AI apps and agents". You send it messages and conversations, it "distills them into facts and links entities across memories", and at query time it "returns only the most relevant memories" (platform overview). It runs as a library inside your own app, or as a self-hosted Docker stack, or as the managed platform, and the open-source engine is the same one the platform runs (open source overview).
Letta is "the platform for building stateful agents", with a customizable memory system, a skills system, and an agent harness the docs call fully open source (docs.letta.com). It is the successor to the MemGPT research project, which framed the model's context window as operating-system memory the model manages itself (MemGPT: Towards LLMs as Operating Systems, arXiv:2310.08560).
Both are pull-shaped: the application, or the agent, decides what to ask for and what to do with the answer. That is the right shape for personalization and for long-lived agent state. It is a weaker shape for governance, because retrieval is a request. A request can be skipped, made at the wrong moment, or made by an agent that does not know the instruction it is retrieving was superseded overnight.
What AirMemo does instead
AirMemo has no retrieval UI and no memory store to query. A memo is pushed into the agent's context at a lifecycle boundary — session start, prompt submit, or the platform's equivalent pre-turn event — which the hook installs on each supported platform.
Every memo carries, at the schema level, a priority of urgent,
important, or info, and a mandatory expiry declared on the column
itself: expires_at TIMESTAMPTZ NOT NULL, annotated in the migration as
"never-nil contract" and "expiry is schema-level required (security
feature)".
A memo is scoped to an org, team, project, channel, or person, so the blast radius of any injection is a decision, not a side effect.
When two memos disagree, the author declares the supersession and the superseded memo is excluded from delivery, so the agent receives the in-force value with its precedence framing instead of both.
And every injection writes a receipt: the proof hash of exactly what the agent was shown, recorded per device and per session.
Side by side
| Memory tools (Mem0, Letta) | AirMemo | |
|---|---|---|
| What it holds | Conversations, extracted facts, and agent state, retrieved by relevance at query time | Governed memos: author-signed, scoped, priority-flagged, with a mandatory expiry |
| How it reaches the agent | The app queries the store, or the agent calls a tool, and the result goes into the prompt | The hook places the memo in the platform's context field at session start or prompt submit |
| What wins when two conflict | Relevance ranking at query time | Author-declared supersession, then the priority ladder; the superseded memo is not delivered |
| Expiry | Entries persist until they are updated or deleted | expires_at is NOT NULL; a sweep expires past-expiry memos and drops their undelivered queue messages, never the record itself |
| Proof of delivery | The store holds the record | A per-delivery receipt with a proof hash of what the agent saw |
| Scope | Organized by user, agent, app, and run | Org, team, project, channel, or person |
They compose
This is a comparison, not a contest. A memory layer can hold an agent's long history. AirMemo decides which governed fact reaches context on the next turn, and proves that it did. Running both is a reasonable answer: Mem0 or Letta for recall, AirMemo for the decisions that must not be missed.
Sources. Every capability attributed to a competitor above is from that vendor's own public documentation, read on 2026-10-06: docs.mem0.ai platform overview, docs.mem0.ai open source overview, docs.letta.com, and arXiv:2310.08560. Every capability attributed to AirMemo is from this repository at HEAD, and the file and line for each sits in the comment beside it.