Hermes Agent vs Letta: Memory Platform or Runtime?

Two Bets About How Agents Should Remember

If you searched "hermes agent vs letta", you probably already know both projects live in the "AI agent with memory" category. What is less obvious is that they place opposite bets on what memory should look like. Letta, formerly MemGPT, gives the agent an OS-inspired tiered memory system with more than 23,000 GitHub stars behind it: core, recall, and archival tiers the model actively manages through function calls. Hermes Agent from Nous Research keeps a small, curated snapshot present in every turn and never asks the model to go retrieve it.

The philosophical split matters because it shapes the entire product. Letta is a platform you drop into your own codebase to build memory-rich agents. Hermes is a runtime you install once and talk to on Telegram, Signal, Discord, or Slack. This post walks through both, where the decision boundary actually sits, and when a hybrid makes sense.

What Letta Actually Does

Letta is the direct descendant of the MemGPT paper from UC Berkeley's Sky Computing Lab. It runs as a server process that manages agent state in a PostgreSQL database, exposed over a REST API at port 8283 with official Python and TypeScript SDKs. There is also an Agent Development Environment for graphical inspection of what an agent knows at any moment.

The memory model is the point of the project. Every Letta agent has three tiers:

• Core memory: a small block that stays in the context window at every turn, functioning as working RAM. Persona, user profile, critical context.
• Recall memory: the full conversation history stored in the database. The agent searches its own past messages instead of relying on the LLM window.
• Archival memory: a vector database for long-term storage. The agent writes observations and retrieves them later by semantic search, scaling to unlimited size.

The agent decides when to read and write across all three by calling memory-management functions during its reasoning loop. This is the self-managing claim: the LLM acts as its own memory controller. When it needs context, it queries. When it learns something worth keeping, it inserts.

Letta is deeply portable. The open Agent File Format (.af) makes an entire agent, memory and all, movable across frameworks and hosts. In May 2026 the team launched Letta Code, a memory-first coding agent that competes directly with other coding assistants. The main letta-ai/letta repo has crossed 23,000 stars with 2,400 forks.

What Letta is not is a finished product for end users. It is a backend. You embed the SDK in a Python or TypeScript service, decide what UI or messaging channel your users see, and manage the PostgreSQL cluster the agents live in.

What Hermes Agent Actually Does

Hermes Agent is an open-source AI agent from Nous Research, first released on 25 February 2026, now at v0.14.0. Unlike Letta, it is not a library you import. It is a runtime you install. You point it at a model provider with your own key and it runs as a long-lived process you reach on Telegram, WhatsApp, Discord, Slack, Signal, or a local CLI, all behind one gateway.

The memory system is deliberately opposite in shape:

• MEMORY.md and USER.md are plain-text files the agent curates about you. They sit in ~/.hermes/memories/ and are injected into the system prompt at every session, present from the first token.
• SQLite session search with FTS5 indexes every conversation, so the agent can look up what you discussed last Thursday.
• Skills are markdown files the agent creates and patches itself after complex tasks (typically five or more tool calls).
• External memory providers are a plug-in layer: Honcho, OpenViking, Mem0, Hindsight, Holographic, RetainDB, ByteRover, and Supermemory can be added if you want knowledge graphs, semantic search, or cross-session user modeling on top of the built-in files.

We covered the built-in memory architecture in the Hermes Agent memory and skills post. The important design choice: the curated snapshot is always present, not retrieved. There is no memory function call, no vector search hop, no risk of the LLM forgetting to query. If it is in the file, it is in the prompt.

Hermes ships six terminal backends (local, Docker, SSH, Daytona, Singularity, Modal) and is MIT-licensed. A small European VPS lands around five euros a month. The marginal cost is your model provider bill, not the runtime.

The Decision Boundary

A useful framing: Letta is for agents you build with tiered self-managed memory, and Hermes is for an agent you run with curated always-on memory.

If you find yourself importing Letta into a service and then rebuilding Telegram bots, cron scheduling, and voice notes on top of it, that is the signal that you are recreating what Hermes ships out of the box. If you find yourself pushing Hermes to store hundreds of megabytes of retrievable historical context and running vector search over it, that is the signal that a tiered memory platform would fit better.

When Letta Wins

Letta is the right answer when:

• You are building an AI product, not running an agent for yourself. Customer support, a domain-specific research assistant, a copilot for your SaaS. The memory model needs to scale per-user across a big application surface.
• You need archival memory at scale. Millions of interactions per user, semantic search over years of history, formal retention policies.
• Your team can operate PostgreSQL and expose the SDK from a service you own end to end.
• You want explicit programmatic control of what the agent inserts, retrieves, and forgets: an audit trail of memory operations, not implicit behavior baked into a prompt.
• You care about portability across frameworks. The .af format is real and it works.

This is the memory-platform category. Letta and its peers (Mem0, Zep) own it. Coverage in Vectorize's Mem0 vs Letta comparison, Atlan's 2026 memory framework roundup, and innobu's 2026 memory landscape overview all reflect the maturity here.

When Hermes Wins

Hermes is the right answer when:

• The agent is yours, not your product's. A personal assistant that knows your style, your projects, your contacts.
• You want zero retrieval latency for the memory that matters. If it is in MEMORY.md, the model sees it before it starts reasoning. No missed lookup, no forgotten query.
• You want the interface to be a chat surface you already use, not a UI you build. Telegram is the primary managed channel; Signal, Discord, Slack, WhatsApp, and CLI are available on self-hosted setups.
• You want to read what your agent knows. MEMORY.md is a plain text file, not a row in a vector database. Auditing what the agent believes about you takes 30 seconds.
• You are fine with the curated bound. Hermes intentionally keeps the always-on snapshot small. It is not a place to dump everything you have ever said.

This is the personal-agent category. Daily digests in your voice. Quick recall over your ongoing projects. Reading-list curation and journaling. We compared Hermes to other personal-assistant options in Hermes Agent vs ChatGPT, Claude, and Gemini, and to workflow tools in Hermes Agent vs n8n.

If that sounds like what you want, Get started with Hermify and skip the install: we run a managed Hermes Agent on Telegram with memory that stays yours, live in about a minute.

Curated Always-On vs Tiered Self-Managed

The genuine philosophical disagreement is worth naming. Letta bets that more memory is better as long as the agent can decide when to fetch it. Hermes bets that less memory is better as long as it is always present.

Both bets are defensible. Under a Letta model, an agent with archival memory can recall an interaction from a year ago because it explicitly went and searched for it. Under a Hermes model, an agent might not have that year-old detail at all, but the things about you that actually matter, your name, your projects, your preferences, are guaranteed to be there without a retrieval call that might fail or hallucinate.

Practically, retrieval-heavy models add latency and failure modes. Every lookup is a chance for the LLM to skip the call, phrase the query wrong, or misinterpret the returned rows. Always-on curated memory has no such failure surface for the things it holds, but it also has a bound. You get a small, high-signal working set, not a searchable archive.

The Honest Hybrid

The two are not mutually exclusive. A reasonable advanced setup:

• Hermes carries the relationship. Your personal agent lives in Telegram or another messenger, holds your curated USER.md and MEMORY.md, and manages skills and cron jobs.
• Letta handles archival at scale. When Hermes needs to search five years of your journaling or hundreds of meeting notes, it dispatches to a Letta service you self-host. Letta returns the retrieved chunks, Hermes weaves them into the reply.

Hermes ships external memory provider plugins for exactly this reason. Honcho, Mem0, Hindsight, and others slot in as retrieval backends. Letta would fit the same slot: bring the tiered memory only when you actually need it. The reverse direction (building a Telegram bot, a scheduler, and a skills system on top of Letta) is harder.

How to Pick

1. If your problem is "I am building an AI product and users need a rich, self-managing memory across a large surface", choose Letta.
2. If your problem is "I want one persistent AI that knows me and acts on my behalf across messaging apps", choose Hermes.
3. If your problem is "I want a personal Hermes-style agent but need a serious archive for one specific workload", run Hermes as the front door and call into a Letta service for that archive.

Forcing either project to do the other's job is the failure mode. Letta is not a finished personal agent for messaging apps. Hermes is not a memory platform for a multi-tenant product. Once you accept that each is optimized for a different customer, the choice gets easy.

Sources

• letta-ai/letta on GitHub
• Letta memory architecture walkthrough - SurePrompts
• Mem0 vs Letta (MemGPT) - Vectorize
• Best AI Agent Memory Frameworks in 2026 - Atlan
• Agent Memory 2026: Mem0, Letta, Zep, Hermes, OpenClaude Compared - innobu
• NousResearch/hermes-agent on GitHub
• Hermes Agent persistent memory documentation