Two people at a whiteboard covered in notes and system sketches, comparing two approaches

MemoryFirst vs Letta: business memory or an agent runtime with its own memory

Market7 min read

Letta is an open-source runtime for building stateful agents; MemoryFirst is cited memory for the agents you already use. Pricing and facts as of 2026-11-14.

by Equipo MemoryFirst

Table of contents
  1. The honest summary
  2. What each one is
  3. Feature table
  4. Pricing, with date and source
  5. Pros and cons of both
  6. Where Letta wins
  7. When to choose Letta
  8. When to choose us
  9. Sources

Search for "memory for AI agents" and both Letta and MemoryFirst show up, yet they solve different problems. Letta is a platform for building stateful agents: each agent owns its memory and edits it itself. MemoryFirst is company memory with citations, which the agents you already use (Claude, ChatGPT, Cursor) connect to over MCP. This article compares them using data from their public websites, accessed on 2026-11-14, and says where each one wins.

The honest summary

  • Choose Letta if you have engineers, want to control the agent runtime, need open source or self-hosting, and memory is part of the product you are building.
  • Choose MemoryFirst if you do not want to build an agent: you want Claude Code, Cursor or ChatGPT to remember your business's decisions, documents and conversations, with every answer citing its source.
  • They are not mutually exclusive. Letta lists support for MCP tools, so in theory a Letta agent could query MemoryFirst. We have not tested it and do not claim it as fact.

One caveat up front: Letta's current website and repository centre on Letta Code and a git-backed memory filesystem, and its README says the older V1 API server now lives on an archive branch. Our knowledge is limited to what its public pages say; anything we could not check is marked as such.

A developer's desk with a laptop, a notebook and a coffee cup in the morning

What each one is

Letta presents itself as an AI research lab in San Francisco, founded by the creators of MemGPT at UC Berkeley's Sky Computing Lab. Its docs call it "the platform for building stateful agents" and offer two paths: managed deployment on Letta Cloud, or running the complete runtime yourself with the Letta App Server. The main repository (letta-ai/letta) is licensed Apache-2.0.

According to its documentation, an agent's memory lives in MemFS, "a git-backed memory filesystem that they can inspect and edit." There is also "dreaming": background subagents that review recent conversations and update memory without interrupting your work.

MemoryFirst ingests your business's events and documents (Gmail and IMAP, Calendar, Drive, Dropbox, OneDrive, Slack, uploaded files and an events API), indexes them with dense search, BM25 and a graph, and answers with citations to the exact source: page, minute, message. It is served through a remote MCP server (15 tools), a REST API and a stdio server. It is not an agent runtime: memory and retrieval only.

Feature table

AspectLettaMemoryFirst
What it isPlatform for building stateful agentsCompany memory consumed by other people's agents
Who uses itDevelopers building agentsTeams and founders using existing agents
Open sourceYes, Apache-2.0 (letta-ai/letta repository)We do not claim it: there is no self-hosted edition of the product
Self-hostingYes (Letta App Server, letta server)No: managed service only
MemoryPer agent, in git-backed MemFS; background "dreaming"Shared across the organization, temporal graph with contradictions resolved
Citations to the sourceWe could not verify this on its pagesYes, span_ref per source type
MCPAppears in its docs; scope not verified by usRemote MCP server (OAuth 2.1 or API key) and stdio
Data connectorsNot verified; its "channels" (Slack, Telegram, Discord, WhatsApp, Signal) are for talking to the agentGmail, IMAP, Calendar, Drive, Dropbox, OneDrive, Slack, file upload
Data locationNot stated on its pricing pageDatabase, embeddings and files in the EU; default inference is not EU-only
Bring your own LLM keyYes, on every planYes, for queries and state regeneration

Pricing, with date and source

Letta's figures come from its pricing page (accessed 2026-11-14):

PlanPriceWhat it includes
Free$0/monthUp to 3 stateful agents, 5 MiB per memory repository, your own API keys
Pro$20/month$20 in credits, up to 20 agents, 50 MiB per memory repository
Teams Pro$20/seat/monthEverything in Pro, plus teammates, shared agents and access control
EnterpriseCustomVolume pricing, RBAC, SAML/OIDC SSO, dedicated support

The page itself warns that real usage depends on the model: chat users often stay within the included credits, casual coding use runs about $100 a month, and power users often exceed $200 a month. With your own keys, spend goes to your model provider.

MemoryFirst's figures come from our pricing page: Free (1 project, memory over MCP and Claude Code hooks, 30-day retention), Pro at 12 EUR a month billed annually (144 EUR a year; monthly billing costs 20% more) with unlimited projects and retention, all connectors, a temporal graph with citations and the morning brief, and Team at 39 EUR a month billed annually (468 EUR a year) with 5 seats and shared team memory. VAT included.

The numbers are not equivalent: Letta charges by agents and model credits, we charge a flat plan. We could not verify total cost on Letta Cloud versus self-hosted Letta.

Pros and cons of both

Letta

Pros: open source under a permissive licence; can be self-hosted; full control of the runtime; memory the agent edits and reorganizes on its own; BYOK on every plan; strong research pedigree.

Cons: you must build and maintain the agent; in the texts we read there is no verifiable-citation feature that points back to the source; the pricing page states neither data location nor certifications; cost with hosted models can grow with usage.

MemoryFirst

Pros: no SDK to maintain; citations to the exact source; memory shared across the team; works with any MCP client; data in the EU; low fixed price.

Cons: no self-hosting; by default the query text and retrieved passages go to Cerebras (US) to write the answer; it is not an agent runtime and cannot be used to build one; some sources (Linear, Sentry, audio) are a plan, not a fact; tenants are separated by query filters plus an optional second barrier, not by separate databases.

A small business owner reviewing printed documents and a tablet

Where Letta wins

  1. Control and code ownership. If the agent is your product, you need the runtime in your hands. We do not offer that.
  2. Self-hosting. For anyone who needs nothing to leave their own infrastructure, Letta has a path; ours is a plan, not a fact.
  3. Memory the agent manages. Its self-editing memory and "dreaming" are a distinctive, mature idea. We retrieve what is stored; we do not have the agent rewrite its own memory.
  4. Code transparency. You can read and audit what it does.

When to choose Letta

  • You are building a product whose core is an agent with a persistent identity.
  • Your engineering team prefers open source and running its own stack.
  • You must self-host because of internal policy.
  • You do not need citations to business documents, but learning memory for the agent itself.

When to choose us

  • You want the agents you already use to remember your business without building anything.
  • You need answers with citations (page, minute, message) so you can verify them.
  • Several people must share one memory, with owner, member and viewer roles.
  • You value having database, embeddings and original files in the EU, knowing that default inference is not and that you can bring your own key.

For wider context, read the AI memory market in 2026 and how to choose a memory layer, which covers Mem0, Supermemory and Zep. You can also read the comparison with Glean, our approach for coding agents and the plans.

Two paths diverging in a quiet forest

Sources

All accessed on 2026-11-14. Anything not listed here could not be verified.

  • Letta, home page: https://www.letta.com (accessed 2026-11-14)
  • Letta, pricing: https://docs.letta.com/letta-code/pricing (accessed 2026-11-14)
  • Letta, documentation: https://docs.letta.com (accessed 2026-11-14)
  • Letta, memory (MemFS and "dreaming"): https://docs.letta.com/letta-code/memory (accessed 2026-11-14)
  • Letta, stateful agents: https://docs.letta.com/concepts/stateful-agents (accessed 2026-11-14)
  • Letta, repository and Apache-2.0 licence: https://github.com/letta-ai/letta (accessed 2026-11-14)
  • MemoryFirst, pricing and feature status: our public pricing page and product documentation.

Try cited memory without building anything

The Free plan includes one project, memory over MCP and the Claude Code hooks.

Start free

Keep reading