Comparison · Updated May 2026

HeurChain vs Letta: different scopes, different jobs.

Letta is an agent runtime where memory lives inside the agent. HeurChain is memory infrastructure external to any agent — ChatGPT, Claude, Cursor, your own code. Different scopes; both legitimate. Here's how each fits.

Methodology — read this first

How we measured this comparison

Dataset: LongMemEval-S (ICLR 2025), 500 questions across 6 reasoning categories.

HeurChain numbers: measured on the heurchain-benchmarks harness (sharded_bench.py and multitenant_bench.py) against the broker in the main repo. Both are public; you can rerun the whole thing.

Letta numbers: from MemGPT paper (arXiv 2310.08560) and current Letta docs where available; left blank otherwise. We do not fabricate competitor numbers.

What we measured: retrieval R@k, MRR, NDCG@10, p50/p95 latency, and end-to-end QA accuracy across three answer-and-grading pipelines.

QA comparison (May 2026): Each pipeline used the same retrieved facts, generated its own answers, and graded those answers with the same model it used to generate them. Across 180 questions (30 in each of six categories), mean QA accuracy was 32.8% for Local 14B, 31.7% for DeepSeek V3.1 671B, and 28.3% for Kimi K2.6. DeepSeek and Kimi returned the same pass/fail verdict on 158 of 180 questions (87.8%). That measures agreement between the two pipelines. It does not measure whether two judges would agree on the same answer, since the answers were generated separately. Full results and evaluation code.

What the per-category results showed: Some retrieved facts summarized what happened in a session without preserving the specific details needed to answer a question. The writeup gives an example where retrieval found the right session but the extracted facts omitted the actual shift assignment. Since both answer generation and grading varied, the score differences do not isolate either step.

What we still need to test: whether extraction that preserves specific assignments, dates, and changes improves QA, and whether independent graders agree when they score identical saved answers.

Bias disclosure: we built and ran this internal benchmark. The model comparison shows how much scores moved across these pipelines, not how well these results generalize. If you're evaluating both systems, the most reliable move is to run them on your data.

Retrieval p95 (fair comparison)
Different shape
Letta's memory I/O is embedded in the agent loop, not exposed as a standalone retrieval metric. HeurChain measures 20.5 ms p95 as a pure memory layer under multi-tenant Docker load. These aren't directly comparable numbers — they measure different things.
Inspectable
Open
Harness + every benchmark number in a public repo. Reproduce or refute on your own data.
Architecture
Bring-your-agent
HeurChain calls into any existing agent via HTTP or MCP. Letta provides the full runtime — memory ships with the agent. Different value, different lock-in profile.

Retrieval-only metrics on LongMemEval-S

Letta doesn't publish standalone retrieval R@k — memory is one layer of a full agent runtime, evaluated end-to-end on task completion. Comparing retrieval directly would mean instrumenting Letta's internal layer, which we haven't done. Our numbers below are HeurChain on LongMemEval-S; treat the cross-system comparison as illustrative of architecture, not of "who wins."

Where this comparison gets muddy: Letta is an agent runtime, not a memory-only service. Comparing retrieval R@k apples-to-apples is category-mixing — Letta's memory is evaluated as part of the whole agent on task benchmarks (MMLU-style, AgentBench-style), not as a standalone retriever. Pick Letta if you want a memory-aware agent runtime. Pick HeurChain if you want a memory layer your existing agents can call into.

Metric HeurChain (dense) HeurChain (hybrid α=0.9) Letta
R@10.5430.542—
R@50.9390.933—
R@100.9720.978—
MRR0.9110.913—
NDCG@100.9110.914—

P95 retrieval latency in context

Latencies from different harnesses on different deployment topologies — not strictly apples-to-apples. The multi-tenant Docker number is the closest analog to what a SaaS would actually serve. The in-process number shows what the algorithm itself is capable of with the network removed.

System / configuration P95 latency Source What it actually measures
HeurChain — multi-tenant load (Docker, 10 tenants concurrent)20.5 msThis benchmarkClosest to production SaaS scenario
Letta agent loop (memory I/O)EmbeddedLetta docsNot exposed as standalone metric
HeurChain — dense, in-process35 msThis benchmarkAlgorithm-only ceiling; no network
HeurChain — BM25 only4.6 msThis benchmarkKeyword-only path; useful for hot queries
Mem0 (reference)200 msMem0 paper Table 1Search latency; stack-specific
LangMem (reference)59,820 msMem0 paper Table 1Vector scan; broken at LongMemEval scale

Architecture comparison

HeurChainLetta
Retrieval methodBM25 + dense (bge-m3) + RRF (tunable α)Tiered virtual memory (core / archival / recall) with dense retrieval over archival
Storage backendRedis (vectors + BM25) + SQLite (metadata)Postgres + pgvector for archival memory
Position in stackExternal memory service called by any agent (ChatGPT, Claude, Cursor, custom)Memory lives inside the Letta agent runtime — agent + memory ship together
Multi-tenant modelPer-tenant namespace + agent_id sub-isolation; published zero-leak verificationPer-agent isolation within a Letta server; multi-tenant deployment is your responsibility
Self-hosted optionSingle Go binary + Redis + SQLiteLetta server + Postgres + pgvector via Docker Compose
API surfaceREST + MCP over Streamable HTTP (Official MCP Registry)Letta REST API (agent-centric) + Python SDK
Coupling to LLM choiceNone — pure retrieval infrastructureLetta loop expects an LLM with tool-calling; ships with provider integrations

When Letta is the better choice

We're not going to pretend HeurChain wins on every dimension. These are real cases where Letta is the better fit:

  1. You don't have an agent runtime yet. Letta gives you the whole loop: LLM orchestration, tool calling, memory. If you're starting from scratch and want one opinionated framework, that's a credible choice.
  2. You like the MemGPT tiered-memory model. Core context / archival / recall is a thoughtful architecture from the original MemGPT paper. If that mental model fits your application, Letta implements it natively.
  3. You want memory tightly coupled to one specific agent. When agent and memory ship together, certain optimizations (eager paging of relevant context, tool-mediated memory ops) are easier than via an external service.
  4. You value the research lineage. MemGPT was an influential paper; Letta is its evolution. There's a real research community around the approach. For research-adjacent work, that matters.

When HeurChain is the better choice

  1. You already have agents you want to add memory to. ChatGPT, Claude, Cursor, n8n, custom scripts — all of these can call HeurChain via HTTP or MCP. Letta would mean porting them into the Letta runtime.
  2. You want memory to outlive any single agent runtime. Your data lives in your HeurChain tenant. Swap models, swap runtimes — memory stays. Letta-managed memory is coupled to the Letta runtime.
  3. Memory is one piece of a larger stack. HeurChain is one service in your architecture. Letta is an opinionated whole. If your team prefers composable infrastructure, that fits.
  4. Multi-tenant SaaS with auditable isolation. Per-tenant namespacing with published zero-leak verification.

Cost — for reference, not the headline

Most readers should pick on architecture fit, not price. Letta Cloud has a free tier; the runtime is Apache-2.0 open source. HeurChain self-host is MIT-licensed. The numbers below exist so you can see them, not because we think they should drive your decision.

If you...HeurChainLetta
Hobby / kicking the tiresFree self-host (MIT)Free tier (Letta Cloud) or self-host (Apache 2.0)
Solo developer, managed$5/mo (Hosted — memory only)Letta Cloud paid plans (full runtime included)
Team, shared workspace$49/mo (Enterprise — memory only)Letta team pricing varies
Enterprise — SOC2, SAMLCustomCustom

Apples vs oranges note: Letta's price covers a full agent runtime (LLM orchestration, tool calling, memory — the whole loop). HeurChain's price covers only the memory layer; you bring the agent. If you don't have an agent runtime yet, Letta gives you more per dollar. If you already have one in ChatGPT / Claude / Cursor, HeurChain adds memory without forcing you to adopt a new runtime.

Reproduce these numbers yourself

  1. Clone heurchain-benchmarks and the main HeurChain repo; pull the LongMemEval-S dataset (instructions in the README).
  2. Run python3 sharded_bench.py for the single-tenant baseline; python3 multitenant_bench.py --mode load --max-tenants 10 for the Docker multi-tenant number.
  3. Re-run on your data — your conversation logs, your documents. Public benchmarks correlate with real workloads, but they're not the same thing.
  4. If our numbers don't reproduce on your hardware, open an issue. We'll fix or correct.

Frequently asked questions

When is Letta the better choice?

Letta is the better choice when you do not have an agent runtime yet and want one opinionated framework that gives you LLM orchestration, tool calling, and memory together. It also fits when the MemGPT tiered-memory model matches your application, when you want memory tightly coupled to one specific agent, or when the MemGPT research lineage and community matter to you.

When is HeurChain the better choice?

HeurChain is the better choice when you already have agents such as ChatGPT, Claude, Cursor, n8n, or custom scripts and want to add memory without porting them into another runtime, and when memory should outlive any single agent so you can swap models or runtimes while the data stays. It also fits teams that prefer composable infrastructure, and multi-tenant SaaS that needs per-tenant namespacing with published zero-leak verification.

How does pricing compare?

HeurChain Hosted is $5/month, and Enterprise is $49/month with additional seats at $9.99/month each; self-hosting is free under the MIT license. Letta Cloud has a free tier and the runtime is Apache-2.0 open source, but its price covers a full agent runtime while HeurChain covers only the memory layer.

Is HeurChain an agent framework like Letta?

No. Letta is an agent runtime with built-in tiered virtual memory, so LLM orchestration, tool calling, and memory ship together and memory lives inside the agent. HeurChain is an external memory service that ChatGPT, Claude, Cursor, or your own code can call over HTTP or MCP, so you bring the agent and HeurChain adds the memory layer.

If HeurChain is a fit, the easiest start is the Hosted plan.

Or self-host the same binary for free. If Letta fits your use case better, use Letta — we'd rather you pick the right tool.

Also compare: vs Mem0 vs Zep vs Letta vs Cognee