Letta vs MemClaw: Agent Framework vs Plug-In Workspace
Compare Letta (formerly MemGPT) and MemClaw for AI agent memory. Framework-level stateful agents vs plug-in workspace memory for Claude Code and OpenClaw.
Your AI agent forgets everything between sessions. You have been searching for a fix, and two very different solutions keep showing up: Letta (the project formerly known as MemGPT) and MemClaw.
Both solve the ai agent memory problem. But they solve it at completely different layers of the stack — and picking the wrong one for your situation means either over-engineering a simple problem or under-building for a complex one.
This guide breaks down what each tool actually does, who each one is built for, and how to decide which approach fits your workflow.
What Letta (MemGPT) Actually Is
Letta started as MemGPT, a research project from UC Berkeley that introduced the idea of giving LLMs their own memory management — letting the model decide what to remember, what to forget, and what to move between working memory and long-term storage.
It has since evolved into a full agent framework. Letta is not a plugin or an add-on. It is an entire platform for building stateful AI agents from scratch. You define agents with persistent memory, tool access, and multi-step reasoning — all managed by Letta's infrastructure.
What you need to set up:
- Install the Letta server (Python package or Docker)
- Configure a database backend (SQLite for dev, PostgreSQL for production)
- Define your agent's memory blocks, tools, and system prompts via the API or SDK
- Connect to your LLM provider (OpenAI, Anthropic, etc.)
- Build your application logic on top of Letta's agent API
This is a developer tool. You are building a custom agent, not adding memory to an existing one.
Where Letta shines:
- Building production AI applications that need sophisticated memory management
- Research projects exploring novel memory architectures
- Custom agents that need to autonomously decide what to remember and forget
- Applications requiring structured memory with different tiers (core, recall, archival)
Where it gets heavy:
Letta is infrastructure. You need to run a server, manage a database, and write code to define your agent's behavior. If you just want Claude Code or OpenClaw to remember your project context between sessions, Letta is like buying a commercial kitchen when you need a lunchbox.
What MemClaw Actually Is
The alternative approach is simpler: instead of rebuilding your agent from scratch, you add a memory layer to the agent you already use.
MemClaw is a skill (plugin) that gives Claude Code, OpenClaw, Gemini CLI, and Codex persistent project workspaces. Each project gets its own isolated workspace with a Living README, Artifacts, and Tasks. The agent reads the workspace at session start and picks up where it left off.
What you need to set up:
# Set API key
export FELO_API_KEY="your-api-key-here"
# Install (Claude Code)
/plugin marketplace add Felo-Inc/memclaw
/plugin install memclaw@memclaw
# Install (OpenClaw)
bash <(curl -s https://raw.githubusercontent.com/Felo-Inc/memclaw/main/scripts/openclaw-install.sh)
Then tell your agent: "Create a workspace called [project name]." Done.
Get your API key at felo.ai/settings/api-keys.
Where MemClaw shines:
- Multi-project workflows where you need isolated context per project
- Non-developers who want ai memory without writing code
- Cross-agent compatibility — same workspace across OpenClaw, Claude Code, Gemini CLI
- Teams that need shared project context
Where it has limits:
MemClaw does not let you customize the memory architecture. You get Living README + Artifacts + Tasks — a structured, opinionated workspace. If you need the agent to autonomously manage tiered memory (deciding what to compress, what to archive, what to forget), that is Letta's territory.
Data is stored in Felo's cloud. For projects requiring local-only storage, this is a real constraint.
The Core Architectural Difference
This is the key distinction most comparisons miss:
Letta replaces your agent. You build a new agent on Letta's framework. Your existing Claude Code or OpenClaw workflow does not apply — you are creating something new.
MemClaw extends your agent. You keep using Claude Code or OpenClaw exactly as before. MemClaw adds a persistent memory layer on top. Your workflow stays the same, but now the agent remembers.
This is not a quality difference. It is an architecture difference. They operate at different levels:
| Letta | MemClaw | |
|---|---|---|
| What it is | Agent framework | Agent skill/plugin |
| You build | A new custom agent | Nothing — install and use |
| Memory model | Tiered (core/recall/archival), agent-managed | Structured workspace (README/Artifacts/Tasks) |
| Memory decisions | Agent decides what to remember/forget | Agent updates workspace as you work |
| Infrastructure | Server + database required | Cloud API (no self-hosting) |
| Target user | Developers building AI applications | Anyone using Claude Code/OpenClaw |
| Multi-project | Build it yourself | Built-in workspace isolation |
| Setup time | Hours to days (depending on complexity) | Under 2 minutes |
Learn how AI agent memory works →
When to Use Letta
Choose Letta if you are building a product, not using a tool.
Specific scenarios where Letta is the right choice:
- You are building a customer-facing AI application that needs persistent memory (a chatbot that remembers user preferences across months of conversations)
- You need the agent to autonomously manage its own memory — deciding what is important enough to keep in working memory vs. what gets archived
- You are doing research on memory architectures and need fine-grained control over how memory is structured and retrieved
- You have a development team that can maintain the Letta server infrastructure
Letta gives you power that MemClaw does not: custom memory schemas, autonomous memory management, and full control over the memory lifecycle. If you need that power, nothing else will do.
The Letta community is active and the documentation is solid. If you are comfortable running Python services and managing databases, the setup is straightforward for a developer tool. The MemGPT research paper that started it all is worth reading even if you end up choosing a different solution — the ideas about self-directed memory management are genuinely novel.
When to Use MemClaw
Choose MemClaw if you are using an agent, not building one.
Specific scenarios where MemClaw is the right choice:
- You use Claude Code or OpenClaw for daily work and want it to remember project context
- You manage multiple projects or clients and need isolated memory per project
- You switch between agents (OpenClaw for research, Claude Code for coding) and need shared context
- You are not a developer, or you are a developer who does not want to maintain memory infrastructure
- You need team members to share project context without file-syncing
The typical MemClaw user is someone who already has a workflow with Claude Code or OpenClaw and just wants it to work better. They do not want to learn a new framework or run a server. They want to open a session, say "load the Acme workspace," and have the agent immediately know what is going on. That is the entire value proposition — ai memory that works without engineering effort.
See how freelancers manage multiple clients →
Can You Use Both?
Yes, and some teams do.
A realistic setup: Letta powers your customer-facing AI product (a support bot with long-term user memory), while MemClaw handles your internal development workflow (keeping Claude Code aware of your codebase decisions across sessions).
They do not compete at the same layer. Letta is infrastructure for building agents. MemClaw is a tool for using agents. The overlap is only in the word "memory."
How MemClaw works across multiple agents →
Quick Decision Guide
"I want Claude Code to remember my project between sessions." → MemClaw. Install in 2 minutes, create a workspace, done.
"I want to build an AI app with persistent user memory." → Letta. Set up the framework, define your memory schema, build your agent.
"I want my AI agent to autonomously manage what it remembers." → Letta. Its tiered memory system (core/recall/archival) is designed for this.
"I manage 5+ projects and need isolated context for each." → MemClaw. One workspace per project, zero cross-contamination.
"I need this working today, not next week." → MemClaw. No server, no database, no code.
"I need full control over the memory architecture." → Letta. You define the memory blocks, the retrieval logic, everything.
Get started with MemClaw → memclaw.me
The Bottom Line
Letta and MemClaw solve the same root problem — AI agents that forget — but at different scales and for different users. Letta is a framework for developers building stateful AI applications. MemClaw is a plugin for people using AI agents in their daily work.
If you are reading this because Claude Code keeps forgetting your project, you probably want MemClaw. If you are reading this because you are architecting an AI product with long-term memory requirements, you probably want Letta.
Both are legitimate solutions. The right one depends on whether you are building an agent or using one.
If you are still exploring the ai agent memory landscape, our complete guide to AI memory for agents covers the full range of approaches — from simple CLAUDE.md files to full framework solutions like Letta. And if you have already decided you want workspace-based memory for your existing agent, the installation guide gets you running in under two minutes.
Disclosure: MemClaw is built by the Felo team. Letta is a powerful open-source framework with capabilities that go well beyond what MemClaw offers — particularly in autonomous memory management and custom memory architectures. We believe the right tool depends on the use case.