Honest Comparison

You don't need a new framework. You need better memory.

Letta (formerly MemGPT) pioneered the idea of letting LLMs manage their own memory. It's a full agent runtime with memory built in. Hebbrix takes a different approach: a standalone memory API that works with whatever you already have.

What you're actually running

The infrastructure behind each approach.

Letta
Your application code
Letta agent runtime
Letta REST API server
Embedding model (local or API)
PostgreSQL + pgvector
Docker containers

6 layers to manage, scale, and monitor

Hebbrix
Your application code
Hebbrix API (hosted)

1 API key. Nothing to host.

Everything below the API layer, the search pipeline, the vector store, the knowledge graph, the embedding models, is managed for you. You focus on your agent. Hebbrix focuses on memory.

Three fundamental differences

1

Who decides what to remember

In Letta, the LLM itself manages memory through tool calls. It decides what to store in "core memory" (a small editable block in the system prompt) and what to archive. This is elegant in theory, but it means memory quality depends entirely on the model you use. GPT-4 handles it well. Smaller models forget things or store noise.

Hebbrix uses an engineered extraction pipeline. When you send text with infer:true, it extracts clean atomic facts through a 3-tier process: embedding classification, LLM fact extraction, and content deduplication. The quality doesn't depend on which model your agent runs.

2

How search actually works

Letta's archival memory uses vector similarity search only. Good for semantic meaning, but it misses things. Try searching for "Sarah from TechCorp" and vector search might return results about "professional contacts" or "corporate partnerships" instead of the exact person you mean.

QUERY: "Sarah from TechCorp mentioned a Q2 deadline"
Vector only (Letta)

Corporate partnership discussions...

Q2 planning meeting notes...

Relevant, but not the right Sarah

5 layer hybrid (Hebbrix)

Sarah Chen, VP Engineering at TechCorp

Mentioned Q2 deadline: March 30 for API v2

Exact match via keyword + graph + semantic

3

Integration cost

Using Letta's memory means running your agents inside Letta's runtime. It has its own agent loops, its own message format, and its own REST API. If you already have agents in LangChain, CrewAI, or your own code, you'd need to rewrite or wrap them.

Hebbrix's chat endpoint is OpenAI compatible. In many cases, adding memory means changing a base URL. Your agent code, your prompts, your orchestration layer, all stay exactly as they are.

21k+
Letta GitHub stars
Apache 2.0
2023
Letta founded
UC Berkeley spinout
< 50ms
Hebbrix search latency
5 layer hybrid
2 min
Hebbrix integration
OpenAI compatible

When Letta is the right choice

Letta pioneered important ideas. Here's when it genuinely fits better.

You want the LLM to manage its own memory autonomously, without any external pipeline
You're starting from scratch and want an all-in-one agent framework with memory built in
You prefer self-hosting everything and have the team to manage Docker, PostgreSQL, and embedding infrastructure
You're researching the LLM-as-OS paradigm from the original MemGPT paper

When Hebbrix fits better

If any of these describe your situation, Hebbrix is probably the faster path.

You already have agents running in LangChain, CrewAI, Dify, or custom code and need to add memory
You want memory quality that doesn't degrade when you switch to a cheaper LLM
You need retrieval that combines semantics, keywords, graph traversal, importance, and recency
You need sub 50ms search for real-time applications like voice agents or live chat
You'd rather not manage Docker, PostgreSQL, embedding models, and server infrastructure

Ready to try a different approach?

The free tier gives you 1,000 memories, full hybrid search, and automatic knowledge graphs. Enough to run a real proof of concept.