
This blog is written by AI for SEO
Helix Foundry vs Letta: Company Ontology or Agent Memory?
Letta and Helix Foundry answer different questions: Letta gives one agent memory it edits and carries between conversations, while Helix Foundry builds one sourced ontology over your company's own systems that every agent and person can query. If you are looking for a Letta alternative because someone asked your agents about customers, orders and contracts across Stripe, Postgres and a CRM, you are probably not looking for a better agent memory. You are looking for a different layer.
This post compares the two honestly. Letta has a real win, and it is worth keeping where it fits. But company-wide memory needs connectors, provenance, review and access control, and those are not what an agent's own memory is for.
Letta vs Helix Foundry in short: agent memory or company ontology
Letta is a runtime for stateful agents. Helix Foundry is an app that turns the tools your company runs on into one connected graph. The unit of memory is different: for Letta it is the agent, for Foundry it is the company.
| Criterion | Letta | Helix Foundry |
|---|---|---|
| What it models | One agent's state across conversations | Your company's customers, orders, contracts and the links between them |
| Where memory comes from | What the agent learns and writes itself | Your databases, tools and documents, synced through connectors |
| Who reads it | The agent that owns it (blocks can be shared across agents) | Every agent and person, via the Analyst, the Helix MCP or the explorer |
| Provenance | Not a documented concept in the stateful-agents docs | Every value traced to the row or document quote it came from |
| Source access | Agent calls tools you give it | Never writes to your sources |
| License | Open source on GitHub | Apache-2.0 |
The rest of this post goes through each row.
What Letta does well: stateful agents with self-editing memory
Letta's real win is that it is a purpose-built stateful agent runtime. Its docs describe agents whose memory, messages and tool calls persist across conversations, even when content leaves the active context window. The repo opens with the pitch: build stateful agents with memory that can learn and improve over time.
The memory model is concrete. Core memory lives in blocks: structured, editable sections, each with a label, description, value and size limit, that stay in the agent's context and can be shared across agents. Archival memory is a searchable store outside the context window that the agent can insert into and search when it needs to. The agent decides what to keep in a block and what to push to archive. That self-editing loop is the point, and it comes from the MemGPT lineage.
If you are building a coding assistant, a companion, or a support agent that should remember a user's preferences and how a long task has gone, this is the right shape. Foundry does not try to replace it. Don't rip Letta out of an agent whose job is to remember its own conversations.
Where agent memory stops and company data begins
Agent memory stops where the facts stop belonging to the agent. A customer's plan lives in Stripe. Their account owner lives in the CRM. Their contract terms live in a PDF. None of that is something an agent learned in conversation. It is data other systems own, and it changes without the agent being told.
Four things go wrong when you stretch agent memory to cover it.
First, ingestion. Someone has to pull rows from Postgres and Stripe into memory and keep them current. A memory block is a place to hold a fact, not a connector to the system that owns it.
Second, identity. The same customer appears as a Stripe customer, a CRM account and a Postgres row with three different keys. An agent that writes its own notes will quietly merge or duplicate them, and nothing marks which was a guess.
Third, provenance. When an agent answers "what is Acme's renewal date?", you need to know whether that came from the contract or from something the agent wrote last Tuesday. Self-edited memory is, by design, the agent's own account of what it knows.
Fourth, scope. Memory that belongs to one agent is invisible to the next agent and to the ops lead who wants to ask the same question. Blocks can be shared across agents, but a shared block is still not one model of the business that people and agents query alike.
That is the line between memory and an ontology. For the longer version of the distinction, see Ontology vs Knowledge Graph: Which Your AI Workflows Need.
How Helix Foundry builds company-wide memory with sources
Helix Foundry connects your databases, tools and documents, has an ontology agent draft one ontology over them, and loads it into HelixDB as one connected graph. Foundry is the app. HelixDB is the database it loads into.
The flow, step by step:
Connect data. Connect your databases, tools and documents to bring in your data. You add a source, test it and sync its tables.
Generate an ontology. Foundry generates a draft of your ontology over the synced data. It is a draft, not a finished schema.
Review. Where sources disagree, the disagreement waits for a person instead of being written as fact. Nothing uncertain lands in the graph without review.
Ask. Use the Analyst to ask questions in plain language, explore the graph, or connect Claude Code, Codex or another agent through the Helix MCP.
Two properties matter most for an agent that must be trusted. Every value traces to the row or document quote it came from, so an answer can be audited back to its source. And Foundry never writes to your sources, so connecting a production Stripe or Postgres is a read, not a risk.
The hard parts of running an ontology over time are correct links between entities and updating the schema and graph as data changes. Foundry exists to handle both. For a worked example of the source side, see Map Postgres Tables to an Ontology for AI Agents, and for what happens when the schema moves, How to Update an Ontology When Your Data Changes.
Run Helix Foundry: local, Helix Cloud, your model
You can run Foundry on your own machine or on Helix Cloud, and bring your own model.
Locally, you can run Foundry with Docker Compose:
git clone https://github.com/helixdb/helix-foundry.git
cd helix-foundry
docker compose up -d --waitYou can also run Foundry on Helix Cloud at foundry.helix-db.com.
For teams, Foundry also runs BYOC (bring your own cloud) and works with self-hosted models and your own inference. You can bring your own model or use your own inference. It is built on object storage with encryption at rest. For the local-model route, see Build an Ontology With a Local LLM: Ollama and LM Studio, and for running it in your own cloud, Self-Hosted Ontology Platform: Run Foundry in Your Cloud.
Foundry is open source under Apache-2.0.
Access, review and trade-offs: when to keep Letta, when to switch
Company data comes with permissions, and this is where an agent's private memory is weakest. Foundry turns on RBAC and enterprise directory sync by default. Access to the sources and to the ontology itself is authenticated, and because every fact and relationship is grounded in a source, a user who can't see a source can't see anything in the ontology grounded by it. Access follows the data, not the agent. The deeper treatment is in Ontology Access Control: Who Sees What Your Agents Know.
Review is the other half. Foundry drafts, and a person approves what is uncertain. That is slower than an agent writing to its own memory, and that is the trade: you accept a review step to get a model of the business you can trust.
So when should you keep Letta, and when should you move?
Keep Letta when the memory is the agent's own: a user's preferences, a long task's history, a persona that evolves. A purpose-built stateful runtime is the better tool.
Add Foundry when agents must answer questions about customers, orders and contracts that live in Stripe, Postgres, a CRM and documents, and when those answers need a source.
Use both when you want a Letta agent to carry its own conversational state and query the company ontology, for example through the Helix MCP, for facts it should never invent.
Foundry is not a stateful agent runtime, and it doesn't try to be one. Letta doesn't try to be a company ontology. Picking the right layer matters more than picking a winner. If you are weighing other memory layers, the same split shows up in Helix Foundry vs Mem0: Company Ontology or User Memory?.
FAQ
See the questions below.
Start with one source and one question your agent keeps getting wrong
Letta is the right home for what an agent learns about its own conversations. It is the wrong home for the facts your company already owns in other systems, because those need connectors, provenance, review and access control. Pick the one question your agent keeps getting wrong about a customer or contract, run docker compose up -d --wait on the Helix Foundry repo, connect that one source, and ask the Analyst. Star helix-foundry on GitHub if the answer comes back with its source attached.