Letta’s Memory Layer Is Quietly Undercutting LangGraph’s Agent Base

The Quiet Threat to LangGraph’s Core

Letta, the startup formerly known as MemGPT, has been methodically building something that LangGraph’s ecosystem didn’t fully account for: a memory layer that doesn’t just store agent context but actively manages it at a production level. That distinction is starting to matter.

What Letta Actually Built – And Why It’s Different

LangGraph’s appeal has always been its graph-based approach to orchestrating multi-step agent workflows. Developers can define nodes, edges, and conditional logic with enough flexibility to build genuinely complex systems. But that flexibility comes with a persistent gap: LangGraph treats memory as something the developer figures out themselves. State gets passed between nodes, sure, but long-term memory – the kind that persists across sessions, users, and agent restarts – is largely the developer’s problem to solve.

Letta approaches the problem from the opposite direction. Its architecture is built around a stateful agent server where memory is not an afterthought plugged in via a vector store call. Instead, Letta maintains a structured in-context memory system it calls “core memory,” alongside archival storage and conversation history that agents can query and update autonomously. The agent decides what to remember, what to surface, and when. That’s a fundamentally different mental model than wiring up a retrieval-augmented generation pipeline on top of a LangGraph node.

The practical gap becomes obvious at scale. A LangGraph-based agent handling thousands of users still needs external memory orchestration – typically a combination of Redis, Pinecone, or a custom Postgres setup – to maintain anything resembling user-aware context. Letta ships that infrastructure as a managed layer. Developers using Letta’s API get persistent agents per user, with memory that survives session boundaries without custom engineering. For teams building consumer-facing products or enterprise SaaS with per-user personalization requirements, that’s a significant reduction in infrastructure overhead.

Letta’s technical roots matter here. The MemGPT research paper, published by Charles Packer and the Berkeley team, introduced the idea of OS-style memory management for LLMs – treating context windows like RAM and long-term storage like a hard drive, with the model itself managing what moves between layers. Letta, the commercial product, operationalized that research into a production-grade agent server. The conceptual clarity of the underlying design gives it an architectural coherence that ad-hoc LangGraph memory setups often lack.

Where LangGraph’s Developer Base Is Starting to Crack

LangGraph’s strongest user base has historically been developers building internal automation tools and RAG pipelines – teams that want control over every part of the workflow and are comfortable assembling their own memory solutions. That profile maps well onto the broader LangChain ecosystem, which prizes composability. But a growing segment of developers are building products that need agent persistence without wanting to become memory infrastructure engineers in the process.

That’s the opening Letta is walking through. When a developer evaluating frameworks asks whether they want to build memory management on top of LangGraph or get it out of the box from Letta, the answer increasingly depends on what they’re building. Internal tooling or data pipelines? LangGraph’s flexibility still wins. User-facing agents with personalization requirements? Letta’s model starts looking significantly more attractive, particularly when time-to-production is a priority.

There’s also a deployment story to consider. Letta ships as a self-hosted server or managed cloud service, which means teams can start with the managed option and migrate to self-hosted as they scale without rewriting agent logic. LangGraph, while capable of production deployment, still requires teams to make more decisions about infrastructure: how to persist graph state, how to handle long-running processes, how to manage memory backends. Those decisions aren’t trivial when engineering bandwidth is limited.

The agent tooling space is also getting crowded at the orchestration layer – with open-source workflow tools like Dify applying pressure from the low-code side – which means LangGraph is getting squeezed from multiple directions simultaneously. Letta isn’t competing on the same axis as those tools, but the net effect is that developers have more alternatives than they did eighteen months ago, and each new option pulls at a different part of LangGraph’s assumed ownership of the “serious agent framework” category.

What makes Letta’s positioning particularly sharp is that it doesn’t require developers to abandon LLM provider preferences or tooling they already use. Letta supports OpenAI, Anthropic, and local models via Ollama, which means the switching cost isn’t about renegotiating the entire stack. A team can drop Letta in as the agent runtime and memory layer while keeping everything else intact. That’s a low-friction wedge that’s harder to argue against than a full framework replacement.

LangChain’s Response Problem

LangChain has invested in LangGraph’s stateful capabilities and continues to iterate on the framework, but the organizational energy at LangChain has arguably been distributed across too many surface areas – LangSmith for observability, LangChain templates, hub integrations – to focus deeply on the memory problem Letta has made its entire identity. That’s not a criticism so much as a structural reality: a horizontally focused company will always have trouble competing against a vertically focused one on any single dimension.

The question LangGraph’s community is now quietly wrestling with is whether memory-as-infrastructure is a layer that belongs inside an orchestration framework or alongside it. Letta has already placed its bet – and the teams migrating away from custom LangGraph memory setups are, implicitly, agreeing with them. Whether LangGraph accelerates its own memory roadmap or concedes that ground entirely will define which part of the agent stack it owns two years from now.