Sentra vs Letta: Org-Wide Memory vs Self-Editing Agent Memory

TL;DR

• Sentra is the stronger choice for any team where more than one agent or person shares memory: one org-wide bi-temporal graph, comprehension at write time, and governance built in.
• Letta (formerly MemGPT) is a capable framework for a single stateful agent that edits its own memory, building on the MemGPT research from UC Berkeley (arxiv.org) — but its memory stays scoped to one agent.
• Letta fits building a single long-running agent that curates its own memory. Sentra fits multi-agent organizations that need one shared, governed source of truth.
• Letta scopes memory to the agent. Sentra shares one graph across the whole company.
• They complement each other. Build the agent on Letta and put Sentra underneath as the memory every agent reads from.

What This Comparison Is About

Letta and Sentra both call themselves memory, but they sit at different layers of the stack. Letta answers "how does one agent manage its own memory across a long-running session?" Sentra answers "how does an entire company, humans and every agent included, share one source of truth?" Choosing between them on a feature checklist misses that they were built for different jobs.

Letta is the open-source framework that grew out of MemGPT, the UC Berkeley paper that treated an LLM like an operating system managing its own context window (arxiv.org). Its agents are stateful: they edit their own memory blocks, page information in and out of context, and persist across sessions. Sentra is the company brain for your teams and agents, a single shared graph where what you teach one agent, every agent remembers.

The distinction shapes everything downstream. An agent-centric framework optimizes for one capable agent that owns and curates its working memory. An org-wide memory layer optimizes for shared knowledge that stays correct across teams, tools, and time. Confuse the two and you either bolt a company knowledge base onto a single agent or under-build the memory an organization actually needs.

At a Glance: Sentra vs Letta

The table contrasts design intent, not a scorecard. Letta gives an agent control over its own memory. Sentra gives a whole company one shared, governed graph.

Letta details trace to the MemGPT paper and the Letta project. Sentra's MEME results trace to KAIST, 2026. The sections below explain why each design lands where it does.

How an Agent Edits Its Own Memory

Letta's defining idea is self-editing memory. An agent holds a set of memory blocks in its context window, the most familiar being a persona block and a human block, and it rewrites those blocks itself as the conversation teaches it something new. When core memory fills up, the agent pages older content out to archival memory and pulls it back when relevant, the operating-system analogy that gave MemGPT its name (arxiv.org).

This puts the model in charge of curation. The agent decides what is worth remembering, edits its own state through function calls, and manages the boundary between in-context and external storage. For a single long-running agent, that autonomy is powerful: the agent builds an increasingly accurate picture of its user and task without a developer hand-managing the context window.

Sentra makes the opposite choice. Rather than asking each agent to curate its own memory, Sentra comprehends facts at write time and stores them in one shared graph against a per-organization ontology. The agent does not manage memory; it reads from and writes to a layer that already understands the organization. Letta optimizes a single agent's self-knowledge. Sentra optimizes a whole company's shared knowledge.

Write-Time Comprehension vs Self-Editing

Both systems do real work before a fact is retrieved, but in different places. Letta's work happens inside the agent loop: the agent reasons about what to keep and edits its blocks. Sentra's work happens at ingestion: each incoming fact is structured against the ontology, linked to its evidence, and connected to existing entities before it ever lands in the graph.

That difference compounds at scale. A self-editing agent is only as consistent as its own running judgment, and two agents editing two separate memories will drift apart. Sentra resolves meaning once, centrally, so every agent that queries later sees the same structured, connected answer. Sentra contrasts this with the vector pattern of storing embeddings at write and guessing structure at query, summarized as "vector search returns what's close, not what's correct."

The practical upshot: Letta gives one agent a memory it maintains itself, which is ideal when that agent is the product. Sentra gives many agents a memory maintained for them, which is ideal when the memory has to be shared and stay correct across teams.

Temporal Awareness and Fact Lifecycle

The hardest memory bug is an agent confidently stating something that used to be true. Letta's tiered memory keeps recent context in core memory and older context in archival storage, which helps surface what is current. But archival recency is not the same as knowing when a fact stopped being true.

Sentra solves this at the data model. Every fact in its graph carries two timestamps, one for when it became true and one for when it stopped being true. An agent can ask what was true in January and get the old answer, then ask what is true now and get the current one, without either leaking into the other. As Sentra puts it, "old facts are invalidated, not deleted." The deprecated fact stays queryable as history but never returns as a current answer. For an organization where pricing, policies, and owners change and people need to know exactly when, that bi-temporal model is the one that holds up.

Scope: One Agent vs the Whole Company

Letta scopes memory to the agent. That is the right design when the agent is the unit of value: a research assistant, a companion, a single long-running operator that should own its state. If you want two Letta agents to share what they each learned, you wire that integration yourself.

Sentra inverts the model. One graph holds everything, and what you teach one agent, every agent remembers. When a sales rep updates a deal in HubSpot and an engineer files a related ticket in Linear, both write into the same org-wide source of truth. That sharing is only safe because Sentra resolves identity continuously, so Sarah Chen in HubSpot, S. Chen in Gmail, and @schen in Slack collapse into one person rather than three. Commitment tracking and contradiction detection then run on that shared graph, surfacing a promise the moment it is spoken and flagging when a new fact invalidates an old one. Per-agent memory has no shared surface for those checks to run against.

Best For: Letta

Reach for Letta when you are building a stateful agent and want it to manage its own memory. A long-running assistant, a companion agent, or an autonomous operator that should curate its own persona and context fits the self-editing model precisely. The open-source Apache 2.0 license, the self-hostable server, and the Agent Development Environment make Letta a strong foundation for developers who want full control of the agent and its memory blocks.

Letta is also the better starting point when the agent itself is the product and you want the model, not a separate service, deciding what to remember. For that job it is a leading framework, not a compromise.

Best For: Sentra

Choose Sentra when more than one agent and more than one team need to read from the same memory. The shared graph means a fact your sales agent learns from HubSpot is immediately available to your support agent and to the human reviewing both. Sentra fits multi-agent orgs where Claude, Cursor, and ChatGPT all need consistent context, cross-team knowledge sharing where a decision in Slack should inform a document in Notion, compliance-sensitive environments that require SOC 2 Type II, ISO 27001, and air-gapped deployment, and operations that track commitments and contradictions at scale.

If your need is one agent curating its own memory, Sentra is more than you need. The org-wide graph earns its place once memory has to be shared and governed.

Can You Use Both?

Yes, and for a multi-agent organization it is the natural setup. Letta gives a single agent a rich, self-managed memory of its own work. Sentra sits underneath as the org-wide brain that every agent and every human reads from. You build the agent on Letta and connect Sentra so a fact taught once is governed and shared everywhere. One curates the working memory inside an agent. The other holds what the whole company knows.

How to Choose

Three questions point you to the right tool.

Start with scope. If you are building one stateful agent that should own its memory, Letta fits the problem exactly. If every agent and every person in your company needs one shared source of truth, Letta's per-agent model works against you and Sentra's shared graph is the right architecture.

Next, weigh governance. If you need bi-temporal fact lifecycles, commitment tracking, contradiction detection, SOC 2 Type II, and ISO 27001, Sentra was built for that load. If your memory stays inside a single agent with no cross-agent audit requirement, Letta carries less overhead.

Last, decide on framework versus layer. Letta is an open-source framework for building agents, self-hostable with full control. Sentra is a managed company brain, available as cloud, isolated VPC, or air-gapped on-prem, with no model training on your data. Many teams answer both, and run Letta agents on top of Sentra as the org-wide layer underneath.

Frequently Asked Questions