Letta vs LangChain for Agent Memory

Memory is what separates a stateless chatbot from an agent that remembers context across sessions. Letta, formerly known as MemGPT, and LangChain take notably different approaches to giving agents memory. The difference is less about features and more about whether memory is the foundation of your agent or a component you add to an existing stack.

Two Architectural Philosophies

Letta is a full agent runtime in which memory management is a core primitive rather than an add-on. The framework is built around the idea that an agent should manage what it remembers, with structured tiers such as an in-context working memory and longer-term archival storage. Memory is not bolted on; it is central to how the agent operates.

LangChain takes the opposite stance. It offers memory as a library you wire into agents, typically built with LangGraph, alongside its broad collection of other components. Its memory tooling can store items in a structured store and run a background manager that extracts useful information, such as user preferences, from conversations. Memory here is one capability among many in a large, general-purpose framework.

Self-Editing vs Background Management

A distinctive Letta feature is self-editing memory: the agent itself decides what to store, update, and forget, actively curating its own context. This puts memory management inside the agent's reasoning loop, which is well suited to long-running agents that need to maintain and revise state over time, much like an operating system juggling what to keep in active memory.

LangChain's approach is more passive by comparison. A background manager can extract and persist information automatically, which is convenient and requires less custom logic, but the agent is not continuously and deliberately reshaping its own memory in the same way. Whether you want active self-management or automatic background extraction is a real design decision that depends on how dynamic your agent's memory needs to be.

Lock-In and Fit With Your Stack

Adopting Letta means adopting it as your agent framework, not just a memory layer. That is a reasonable commitment if memory is central to your use case and you want a runtime designed around it, but it is a larger decision than adding a single library. You are choosing an opinionated foundation.

LangChain's memory tooling generally assumes you are working within its ecosystem, particularly LangGraph. For teams already building on LangChain and LangGraph, that is a natural extension with little additional adoption cost. For teams not already invested there, it pulls you toward that ecosystem. In both cases, your memory choice is entangled with a broader framework commitment, so it helps to consider where you want your agent's center of gravity to live.

Choosing Between Them

Choose Letta if you are building long-running agents where memory is the heart of the system and you want a runtime that treats memory as a first-class, self-managed primitive. Choose LangChain's memory tooling if you are already running on LangChain and LangGraph and want to add memory as a component within that stack. The decision is largely about whether memory is your foundation or a feature you are attaching to an existing architecture.