MemroOS and Letta are both serious platforms for agentic memory, and they're built on fundamentally different architectural philosophies. Understanding the difference is essential for choosing the right platform.
MemroOS is a governed multi-agent memory and orchestration platform. Its core design decisions — typed memory tiers, operator-controlled write paths, NOC console, audit lineage — are oriented toward enterprise deployments with multiple agents, compliance requirements, and operator oversight.
Letta (formerly MemGPT) is a framework for building stateful agents using an in-context memory management model. Its origin is the MemGPT research, which showed that LLMs could manage their own memory by treating the context window as a working store and offloading to external memory as needed.
Both are capable. The choice depends on what you're building.
Benchmark Scores
On the Marketplace Agentic Memory Benchmark:
- MemroOS: 84/100
- Letta: 62/100
The gap reflects architectural differences, not quality differences. Letta scores lower on governance and multi-agent memory isolation because those aren't its design priorities — not because it's poorly built.
Architectural Comparison
Memory Model
MemroOS uses a multi-tier typed memory model: vector (semantic search), graph (relationship traversal), episodic (time-ordered observations), knowledge (stable facts and rules), and skills (procedural memory). Each tier has distinct retrieval patterns and decay behavior.
Letta uses the MemGPT model: the agent maintains a main context (in-window memory) and external storage. When the main context fills, the agent itself decides what to archive and what to load — the agent manages its own memory.
The difference matters for orchestration: MemroOS's memory tiers are managed by the platform, visible to operators, and governed by access controls. Letta's memory management is delegated to the agent, which gives agents more autonomy but reduces operator visibility.
Governance
MemroOS provides per-agent write permissions, operator-gated promotion for high-trust writes, and full audit lineage on every memory mutation. Designed for deployments where you need to know what each agent wrote and why.
Letta does not currently provide per-agent memory write permissions or operator approval gates. Memory governance is the responsibility of the application layer.
For consumer applications, this doesn't matter. For enterprise deployments handling sensitive data or requiring compliance evidence, it does.
Orchestration Integration
MemroOS integrates memory with orchestration: every agent run has a context pack assembled from governed memory, HIL checkpoints can block progression and write to audit memory, and rollback affects the memory state. The orchestration and memory layers are unified.
Letta provides agent orchestration through its own framework but doesn't deeply integrate memory state with checkpoint/rollback operations.
Self-Hosting and Deployment
Both platforms support self-hosting. MemroOS is local-first by design — the default deployment is self-hosted, with all data staying within the operator's infrastructure. Letta supports self-hosting via its open-source release but is also available as a cloud service.
Developer Experience
Letta has excellent developer experience for Python agent development. The MemGPT model is well-documented, the SDK is mature, and there's a large community around it.
MemroOS integrates with Claude Code via MCP, which provides excellent developer experience for Claude Code users. REST API compatibility makes it framework-agnostic.
Side-by-Side Comparison
| Criterion | MemroOS | Letta | |-----------|---------|-------| | Benchmark Score | 84/100 | 62/100 | | Memory Architecture | Multi-tier typed (5 tiers) | MemGPT in-context model | | Governance | Per-agent permissions + audit trail | Application-layer responsibility | | Orchestration | Unified with memory | Agent-centric | | Self-hosted | Yes (local-first default) | Yes (also cloud available) | | Audit trail | Full lineage on every mutation | None built-in | | NOC console | Yes | No | | Python SDK | REST/MCP | Native Python | | LangGraph integration | Yes | No | | Multi-agent memory isolation | Operator-controlled | Not built-in |
When to Choose Letta
- You're building Python-native stateful agents and want a framework that handles the full agent lifecycle
- Your agents need to manage their own memory context dynamically (the MemGPT model is specifically designed for this)
- You want a large open-source community with extensive examples and documentation
- Governance and compliance are not requirements for your deployment
When to Choose MemroOS
- You need per-agent memory governance, audit trails, or compliance evidence
- You're deploying multiple agents that share memory and need isolation controls
- You want operator visibility into what agents are doing with memory (NOC console)
- Your deployment is local-first or has data residency requirements
- You're using Claude Code and want native MCP integration
- Your agents use LangGraph, CrewAI, or other non-Letta frameworks
Summary
Letta is the right choice if you're building Python agents that need sophisticated in-context memory management and want a mature framework with community support. MemroOS is the right choice if you're deploying in an environment that requires governance, compliance, operator visibility, or multi-framework support.
Both are serious platforms. The question is which architectural philosophy matches your deployment requirements.