Ambience vs Letta
Letta is the commercial successor to MemGPT, by the original authors. Open-source server, hosted Cloud. The architecture is the most interesting in the category. Agents edit their own memory blocks via tool calls, blocks can be shared across agents, MemFS treats memory as a git-tracked filesystem. We do something different.
Use Lettaif 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.
Use Ambienceif 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.
Where Letta wins
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 most architecturally interesting agent-memory design and self-host ability, Letta wins.
We send agent-architecture researchers and individual stateful-agent builders to Letta. We mean that. They're a great team shipping a great product.
Where Ambience wins
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 wins clean here. | 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
Pick Lettaif 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 Ambienceif 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. Different layers.
Team context, not single-agent memory.
If you're a team running AI agents at work, install Ambience and find out what you've been losing.
curl -fsSL https://ambience.sh/install.sh | shRead the category essay: Single-agent memory vs team context. Or the full reference for AI agents.