Ambience vs Letta
Letta is the commercial successor to MemGPT, with self-editing memory blocks, MemFS, and an open-source server. Ambience is the governed memory plane for teams that need shared context with scope, redaction, SSO, revocation, and audit.
Letta fits when you're building stateful agents and want the agent itself to reason about what it remembers. What to write to a memory block, what to push to archival storage, what to recall. Letta's programming model is genuinely differentiated, and shared memory blocks across agents is the closest thing in the single-agent-memory category to a multi-agent primitive.
Ambience is the better fit if you're a team running AI agents at work and need a substrate that captures durable organisational context. Decisions, conventions, skills, failure modes, across people, with scopes the security team will recognise and an audit log they'll trust. Different product. The category essay covers why these aren't the same thing.
What Letta optimizes for
Letta's memory blocks are first-class objects with block_ids, attachable to multiple agents. “Update once, visible everywhere.” That's a real primitive nobody else in the category ships. The MemFS feature treats memory as a git-tracked filesystem, which is interesting both for auditability and for the “agent debugs its own context” workflow.
The OSS server (letta-ai/letta) is Apache-2.0 and self-hostable. Original MemGPT DMR results (93.4%) are the canonical reference. If you want the agent itself to manage its own memory and you need self-hostable OSS, Letta is optimized for that layer.
That is still a different buying question from team context. Ambience is designed for the organization around the agents: who can read which memory, what was redacted, what changed, and what an admin can prove later.
Why Ambience is stronger for team context
Letta's primary unit is an agent, or one person with a small number of agents. The Cloud pricing tiers are individual SKUs (Pro $20, Max $200, API $20/mo + per-agent + per-second tool execution). There is no published enterprise/SSO tier. Consistent with the product's focus, but it means it's not built for the questions a team running internal agents has to answer.
1. Multi-tenant org model with team scopes. Letta shares memory via block IDs attached to agents. Agent-to-agent sharing, not policy-based scope. Ambience has personal, team, project, org, sensitive with server-enforced policy. Sharing is governed, not delegated.
2. Server-side redaction before storage. Letta doesn't document a redaction primitive. Memory blocks are written by the agent, and the agent is also the safety boundary. For team use that boundary is too thin. Ambience strips secrets and PII server-side before any write touches storage.
3. Append-only audit independent of agent. MemFS's git-tracked memory is the closest analog to audit in the category, but it's per-agent and visible to the agent. Ambience writes an append-only audit row for every read and every write, independent of the agent, visible only to org admins.
4. SSO and identity-based revocation. Letta's public pricing has no SSO tier. Identity is per-account. Ambience ships Google, GitHub, and SAML SSO via WorkOS. Revocation is one action with an audit row.
5. Pricing shape for teams. Letta's Cloud pricing scales by agent count andtool-exec seconds. Two-axis variability that fits individual users but doesn't model cleanly for a team buyer. Ambience also prices on agents, but only active agents (≥1 read or write in the month), at a flat $9. Idle agents stay free, the bill is single-axis, and domain-claim auto-join handles team expansion.
Side-by-side
| Capability | Area | Ambience | Letta |
|---|---|---|---|
| Primary use case | Fit | Team / org context for internal agents | Stateful agent platform |
| Mechanism | Architecture | Typed memory store with policy-enforced scopes | Self-editing memory blocks + virtual context (MemGPT-style) |
| Sharing model | Architecture | Server-enforced scope policy | Memory blocks attached to multiple agents |
| Server-side redaction before storage Letta's safety boundary is the agent itself. | Security | Yes | No |
| Append-only audit (independent of agent) MemFS is git-tracked but per-agent, not org-wide. | Governance | Yes | No |
| SSO (Google / GitHub / SAML) No published SSO tier on Letta Cloud. | Governance | Yes | No |
| Self-hostable OSS Letta is optimized for self-hostable agent architecture. Ambience is optimized for governed team context. | Memory | Coming | Yes |
| MCP integration | Memory | Yes | Yes |
| Pricing shape | Fit | $9 per active agent / month, idle free | Per-agent + per-second tool execution |
Last verified against Letta docs and pricing pages, May 2026: source. If anything is wrong, email hello@ambience.sh and we'll fix it.
Use this rule
Letta mainly fits if you're a researcher or stateful-agent builder, if your design problem is “how should an agent reason about its own memory,” or if you want self-hostable OSS with a clean programming model.
Pick Ambience if you're building internal tooling for a team and the questions on the table are scope, redaction, audit, and SSO. Not agent architecture.
Some teams will run both. Letta for the stateful agents themselves, Ambience as the org-wide context substrate the agents read from at session boundaries, with policy and audit owned outside the agent.
Make team context trustworthy.
Ambience gives agent memory the controls teams actually need: scope, redaction, conflict review, audit, and proof that context is being reused.
Install AmbienceRead the category essay: Single-agent memory vs team context. Or the full reference for AI agents.