Letta lets the model manage memoryStatewave manages memory for the model
Letta hands memory to the model and lets it decide. Statewave assembles a deterministic, token-bounded context bundle and can return an integrity-hashed receipt of what the agent saw.
ContextAssembler
deterministic · token-bounded
The model manages memory, or a runtime does
Letta gives the agent tools to edit its own memory blocks, tracked as commits in a git-backed context tree (MemFS): memory is the model's job, decided turn by turn and paid for in tokens. Statewave ingests each event as an immutable episode, compiles it into typed memories, and assembles a ranked bundle the same way every call, with no model in the loop.
Retrieval rides on the model
There's no ranking or expiry step: the agent reads and edits its own context tree directly, and whatever it last wrote is what it sees next time. Every operation spends inference tokens, and an unwritten fact is gone.
Assembly is deterministic and inspectable
Given the same subject, task, token budget, and point in time, the assembler returns the identical bundle every run. Four signals set the order: kind priority, recency, task relevance, and temporal validity.
Where each capability lives
Both give agents memory. They diverge on who does the work (the model, or the runtime) and on what you can prove once it has.
How context is selected
- la
- The agent reads and edits its own context tree with tool calls
- S
- Deterministic assembly, ranked to a token budget
What ranks results
- la
- The model’s judgment, turn by turn
- S
- Kind priority, recency, relevance, validity
Cost of retrieval
- la
- Inference tokens on every memory operation
- S
- Mechanical; no LLM on the read path
Same query, same result
- la
- Varies with the model and its tool choices
- S
- Byte-identical bundle every run
Proof of what the agent saw
- la
- None; reconstruct it from message logs
- S
- Immutable, ULID-addressable receipt with an integrity hash
Policy on the read path
- la
- Implement it in your app or tools
- S
- Declarative bundles: deny or redact by label and caller
Reliability of capture
- la
- If the model does not save it, it is gone
- S
- Every event recorded as an immutable episode
Subject deletion (GDPR)
- la
- Remove or rewrite files in the context tree directly
- S
- One call clears episodes, memories, and receipts
Scope
- la
- A full stateful-agent platform: you adopt the runtime
- S
- A memory layer that drops into your existing stack
Storage
- la
- Self-hosted App Server (Docker Compose, Railway, or Fly.io); memory lives in git-tracked MemFS, no separate archival store
- S
- Postgres and pgvector, nothing else to run
Interface
- la
- CLI (letta-code), desktop app, chat.letta.com, Slack/Telegram/Discord
- S
- REST, Python and TypeScript SDKs, MCP server, connectors
License
- la
- Apache 2.0, with managed Letta Cloud
- S
- Apache 2.0 throughout, runs fully offline
Letta (formerly MemGPT) manages memory through the agent's own tool calls against a git-tracked context tree (MemFS), so retrieval depends on the model driving it. Rows reflect each product's public docs and source as of August 2026.
You're building agent-first, want the model to manage its own context, and value adaptive, self-editing memory over reproducibility or an audit trail.
Agents run in production across many sessions and you need deterministic context, source provenance, policy on the read path, and an optional auditable receipt for every decision.
One returning customer, two runtimes
A support agent resumes a customer thread three weeks later. In between, the customer moved house and pasted a card number into an earlier message. The same episode history runs through each system.
Every call can leave a receipt
Letta leaves auditability to your application and its message logs. Statewave governs assembly on the read path and emits an immutable receipt, all in the Apache 2.0 core.
The benchmarks Statewave has tested
Statewave's scores are fixed: no model sits on the read path, so the same subject and budget return the same answer every run. Letta has published a LoCoMo figure of its own (74.0%, GPT-4o mini, above Mem0's 68.5%), but not one produced under the same conditions as this harness. What it does publish continuously is a leaderboard that scores the driving LLM, and the same runtime swings 56 points and 21× in cost by model.
Letta's leaderboard runs the identical runtime across 15 LLMs. The score is the model's, not the memory's: pick a different model and it moves. leaderboard.letta.com
Context-Bench measures an agent's context engineering, not a memory layer in isolation, so it is not comparable to the LoCoMo and LongMemEval figures above. It is shown instead to make the opposite point: the number moves with the model. leaderboard.letta.com, last updated 13 March 2026.
Add Statewave to your Letta stack
Letta is the whole agent runtime; Statewave is only the memory layer. Keep your agent loop and point its memory calls at Statewave: each write lands as an immutable episode.
Frequently asked
How is Statewave different from Letta?
In Letta the agent manages its own memory: it edits memory blocks in a git-tracked context tree (MemFS) with tool calls, so retrieval is the model’s job and costs tokens every turn. Statewave compiles episodes into typed memories, ranks them to a token budget, applies policy on the read path, and can return an integrity-hashed receipt, with no model in the loop.
Do I have to replace my agent framework?
No. Letta is a whole agent runtime; Statewave is only the memory layer. Keep your existing agent or framework and point its memory reads and writes at Statewave over REST, the SDKs, or MCP.
What makes retrieval deterministic?
A fixed scoring model applied to a hybrid lexical and vector candidate set: kind priority (3–10), recency (0–5), task relevance (0–8), and temporal validity (−4 to +3). The same subject, task, budget, and point in time produce the same bundle every time.
What is a state-assembly receipt?
An immutable, ULID-addressable record of one context call. It carries a byte-level integrity hash of what was delivered and references the policy bundle hash, so ‘what did the agent see, under which policy’ is answerable forever.
Does it work with Claude, Cursor, or Codex?
Yes. One command (npx @statewavedev/statewave) boots the runtime, and its shipped MCP server connects any MCP-compatible client: Claude, Cursor, Copilot, and agent runtimes.
Can I run it fully offline?
Yes. Storage is Postgres-only and self-hosted. The heuristic compiler keeps everything on your network; nothing leaves unless you configure an LLM compiler or hosted embeddings.
Give your agent context it can prove
Self-host the Apache 2.0 runtime, wire it to your MCP client, and every context call can return a receipt.