AirMemo and the memory tools
Memory is a store. AirMemo is a delivery layer.
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.
Is AirMemo a memory tool?
No. A memory tool keeps what an agent has been told and returns the part a query asks for. AirMemo keeps governed memos, decides which of them reaches an agent next, and proves the delivery. That difference shows up on a Tuesday: a memory tool answers correctly when something asks it, and an agent that never asks learns nothing; AirMemo puts the in-force decision in front of the model before the turn, and a receipt records what it saw. The two are one stack, not one choice. Run Mem0 or Letta for recall, and AirMemo for the decisions that must not be missed.
What the memory tools do
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.
Mem0 calls itself "the fully managed memory layer for your 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.
Why this mattersA 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. The store stays correct the whole time: what failed is the delivery.
What AirMemo does instead
The gateway is the first rail, because it needs no cooperation from the agent's code. Point a client's base URL at the org gateway and the org's in-force memos are added to the request itself, ahead of the call to the model vendor; the vendor's response streams back untouched and no request or response body is stored. The only thing that changes is what the model was told in front of the prompt.
AirMemo has no retrieval UI and no memory store to query. Where an agent exposes lifecycle events, the hook pushes a memo into its context at a boundary: session start, prompt submit, or the platform's equivalent pre-turn event. The installer writes that hook on the five runtimes whose events carry a context field: Claude Code, Codex, Copilot, Cursor, Gemini CLI. Windsurf's Cascade hooks carry no such field (the runtime reads only the exit code), so it takes delivery over the hosted MCP endpoint; OpenCode has no command hook at all and takes it through a plugin. Every rail delivers the same authored memos, and none of them asks the model to go looking.
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 once, under a block that names it organization policy and says plainly that it comes from the org rather than the user.
And every injection writes a receipt: the proof hash of exactly what the agent was shown, recorded per agent 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 gateway adds the memos to the outgoing request; where an agent exposes lifecycle events, the hook places them in the platform's context field at session start or prompt submit |
| What wins when two conflict | Relevance ranking at query time | The author declares one superseded and it is not delivered; with no declaration both are delivered, urgent first |
| 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 the product as it ships, and the measurements behind its claims, with the bounds on them, are on Evidence.