The memory wars are heating up, and one question dominates: should agents manage their own memory, or should memory manage itself? A year ago, this wasn't even a question — agents had no memory beyond context windows. Today, we're debating whether they should actively edit what they remember or passively query enriched knowledge graphs.
Enter Letta (formerly MemGPT) and Graphlit — two platforms representing fundamentally different philosophies about agent memory. Letta pioneered the idea that agents should actively edit their own memory, using structured in-context blocks they can modify during conversations. Graphlit takes a broader view: agents need comprehensive semantic infrastructure that spans all their data sources, not just conversations.
If you're building production agents and evaluating memory platforms, this comparison will help you understand the architectural differences, deployment trade-offs, and when each platform makes sense.
TL;DR — Quick Feature Comparison
Understanding the Platforms
What is Letta?
Letta is built on the groundbreaking MemGPT research paper, which introduced the concept of an "LLM Operating System" for memory management. The core insight: agents shouldn't just read from memory — they should actively manage it.
Letta agents maintain core memory blocks — structured sections of their context window that persist across all interactions. These blocks are always visible (no retrieval needed), and agents edit them autonomously using built-in tools:
memory_replace— Find and replace for precise editsmemory_insert— Add new information to a memory blockmemory_rethink— Completely rewrite a memory block
When a user says "I switched from Python to TypeScript," the agent doesn't just store a log entry — it actively updates its memory block about your tech stack. This self-editing capability makes Letta agents feel more intentional and aware.
Beyond core memory, Letta provides external memory systems:
- Conversation search (full-text and semantic)
- Archival memory (agent-managed knowledge database)
- Letta Filesystem (document management)
Letta is available as a managed service (Letta Cloud) or self-hosted for teams that need infrastructure control.
What is Graphlit?
Graphlit approaches memory as semantic infrastructure rather than just conversation management. We're built for agents that need to understand and connect knowledge across diverse sources — not just chat history, but documents, audio transcripts, video, web pages, API data, and more.
When you ingest content into Graphlit, we:
- Extract structured entities (people, organizations, places, events)
- Build relationship graphs between concepts
- Embed content semantically for hybrid search
- Parse temporal context and citations
- Link everything into a per-user knowledge graph
The result: agents don't just remember conversations — they understand how ideas connect across every piece of content they've seen. Search for "pricing discussions" and get relevant Slack threads, meeting transcripts, sales docs, and customer emails — all connected semantically.
Where Letta focuses on conversation-first memory with agent-controlled editing, Graphlit provides comprehensive memory infrastructure across all modalities and sources.
Memory Model Differences
Letta's Core Memory Blocks are the platform's signature feature. These structured, labeled sections of the context window (like "User Preferences" or "Project Status") persist across conversations. Agents see them always and edit them directly:
Core Memory Block: "User Preferences"
- Primary language: TypeScript
- Testing framework: Vitest
- Deployment: Vercel
- Last updated: user switched from Jest to Vitest on 10/15
This gives agents a persistent scratchpad they actively maintain. It's powerful for conversational agents that need to track evolving information.
Graphlit's Knowledge Graph takes a different approach: we extract entities and relationships automatically, storing them in a semantic graph that spans all content types. Instead of agents editing memory blocks, they query a rich knowledge base:
Entities: [User: Alice] → (prefers) → [Framework: Vitest]
[User: Alice] → (works_on) → [Project: Zine]
[Project: Zine] → (uses) → [Platform: Vercel]
Content: Meeting transcript "Sprint Planning 10/15"
GitHub PR #123 "Switch to Vitest"
Slack thread discussing test migration
Letta's model is more agent-centric (the agent manages memory). Graphlit's is more content-centric (memory emerges from structured understanding).
Ingestion: Conversations vs. Comprehensive Content
Letta is optimized for conversational data. You ingest messages and structured events, which Letta processes into its memory hierarchy. This works beautifully for chat applications but requires custom pipelines for other content types. If you want to give your agent knowledge from documents, meeting recordings, or external systems, you'll need to build ingestion logic.
Graphlit provides 30+ pre-built connectors out of the box:
- Communication: Slack, Discord, email, RSS feeds
- Development: GitHub, Jira, Linear, GitLab
- Documents: PDF, DOCX, PPTX, Markdown, HTML
- Media: Audio (with transcription), video (with scene analysis), images (with OCR)
- Web: URL ingestion, sitemaps, web scraping
Graphlit continuously syncs data and automatically extracts entities, transcribes audio, generates summaries, and builds knowledge graphs. This "unified semantic layer" approach means agents have memory across all their information sources, not just conversations.
Search and Retrieval Architecture
Letta provides three search mechanisms:
- Conversation search — Retrieve past messages (full-text and semantic)
- Archival memory search — Query the agent-managed knowledge database
- Filesystem — Access documents and files
These tools are exposed to agents, who decide when to search. The emphasis is on giving agents control over memory access.
Graphlit offers unified hybrid search across all content:
- Vector semantic search (find conceptually similar content)
- Keyword search with BM25 ranking
- Graph-aware context expansion (find related entities)
- Entity filters ("show me content where Alice discussed pricing")
- Temporal filters (date ranges, content age)
- Metadata filters (type, source, user, collection)
Graphlit's retrieval is more semantically expressive because we've already structured the content into entities, relationships, and knowledge graphs. You're not just searching text — you're traversing connected knowledge.
Developer Experience and Deployment
Letta offers two deployment options:
- Letta Cloud: Managed service with REST API and usage-based pricing
- Self-hosted: Full control using open-source components
The Python SDK is mature and well-documented. The Agent Development Environment (ADE) lets you visualize agent memory and reasoning in real-time. For teams comfortable with infrastructure, self-hosting gives maximum control.
Graphlit is cloud-native only — no self-hosting option. This is a deliberate design choice: we handle scalability, multi-tenancy, and infrastructure so you can focus on building agents. Our SDKs (Python, JavaScript/TypeScript, C#) provide a unified API for ingestion, search, and chat. We integrate with agent frameworks via MCP (Model Context Protocol).
If you need on-premise deployment, Letta's self-hosted option wins. If you want turnkey infrastructure, Graphlit is the better fit.
Memory Management: Active vs. Automated
This is the philosophical divide between the platforms:
Letta believes agents should control memory. Agents use tools to edit core memory, decide what to store in archival memory, and choose when to search. This gives agents agency and makes memory management transparent.
Graphlit believes memory should emerge from content understanding. We automatically extract entities, build graphs, and enrich content semantically. Agents query structured knowledge rather than editing raw memory blocks.
Both approaches have merit:
- Letta's active management makes agent behavior more interpretable and controllable
- Graphlit's automated enrichment scales better across diverse content types and sources
The right choice depends on your use case complexity and data diversity.
Use Cases: When to Choose Each
Choose Letta if:
- You're building conversational agents (chatbots, assistants, support bots)
- You want agents to actively manage and edit their own memory
- You need transparency into how memory changes over time
- You prefer self-hosting or need on-premise deployment
- Your memory needs are primarily conversation-focused
Choose Graphlit if:
- Your agents need to understand multimodal content (audio, video, documents)
- You want unified memory across 30+ data sources and platforms
- You need entity-aware semantic search and knowledge graphs
- You prefer managed infrastructure
- Your agents operate across diverse content types, not just conversations
- You want turnkey integration without building ingestion pipelines
Final Verdict: Conversation Memory vs. Comprehensive Infrastructure
Letta is an exceptional platform for building conversational agents that actively manage their own memory. Its self-editing core memory blocks and temporal conversation tracking make it ideal for chat-first applications where transparency and agent control matter.
But as agents evolve beyond chatbots — as they start managing projects, analyzing documents, connecting ideas across sources, and operating autonomously — they need memory infrastructure that goes beyond conversations.
That's why we built Graphlit.
With native multimodal support, 30+ connectors, automated entity extraction, knowledge graphs that span all content types, and enterprise-grade infrastructure, Graphlit provides the comprehensive semantic memory layer that production agents require.
Letta pioneered the idea of agents editing their own memory — a powerful concept. Graphlit takes the next step: giving agents rich, structured, multimodal memory that emerges from truly understanding their data.
Both platforms represent cutting-edge agent memory architecture. The choice comes down to scope: conversation-first with agent control (Letta) vs. comprehensive semantic infrastructure (Graphlit).
Explore more:
Your agent's memory shouldn't be a filing cabinet. It should be a living brain.