The short answer
As of September 22, 2026. Products change; we re-check this page regularly.
Letta and thinqOS are different shapes, so parts of this comparison are not like for like. Letta is an agent harness: one long-lived agent that rewrites its own prompt, memory files and skills, with a background process that reflects on what it learned. thinqOS is a Mind that belongs to an identity, a person or an agent, and the runtime maintains it, not the model. Letta is ahead on openness, self-hosting, memory you can read as plain files, and learning directed by the agent. thinqOS is ahead on the state of each belief, and on reaching the same Mind from several tools.
What each one is
Letta grew out of the MemGPT research project. Its current product is Letta Code, an Apache 2.0 TypeScript project with a command-line tool, desktop and web apps, and a local backend. We read it at the commit dated September 22, 2026. The older Python server, with memory blocks and archival search, is retired and kept on an archive branch.
In Letta Code, memory is a folder of markdown files in a git repository. Top-level files go into the agent's prompt; files in subfolders load when the agent reads them. The agent edits these files with tools and commits the changes. A reflection subagent, which Letta calls dreaming, runs after the conversation is compacted or after a set number of steps, and updates memory and skills. When memory is out of date, Letta's reflection prompt tells the agent to fix the old entry rather than keep both.
In thinqOS, the model inside the product does not write beliefs by tool call. Beliefs arrive by automatic extraction from conversations, then confidence blending, decay and consolidation adjust them. Tools outside thinqOS can also write to a Mind over MCP.
| Letta | thinqOS | |
|---|---|---|
| Open source, self-hostable | Yes, Apache 2.0; local backend | Not open source; self-hosting with an install token we issue |
| Who writes memory | The agent, through tools | The runtime, from conversations; outside tools over MCP |
| Form of memory | Markdown files in git | Structured beliefs with confidence and salience |
| Confidence on each memory | No | Yes |
| Decay and forgetting | No; the agent moves files by hand | Salience decays; low, unprotected beliefs archived |
| Contradictions | Old entry rewritten; history in git | Kept linked; checked on confirm, state or resolve |
| Learning from experience | Reflection writes memory and skills | Partial |
| History and undo | Git history and revert | Event log; no single-change undo found |
| Reach from other tools | MCP client only | MCP server; capture from coding tools |
| Access control per memory | Organization scoping; read-only blocks (retired server) | Audience per belief |
Who should choose Letta instead
We would point you to Letta in these cases.
You are building an agent product, such as a coding agent, a support bot or a companion, and you want one long-lived agent that rewrites its own prompt, memory and skills. That is what Letta is built for.
You need a permissive license, or you want to run fully locally with no vendor account. Letta Code's local backend does this. thinqOS is not open source. It can be self-hosted from a signed release, with an install token we issue for each installation.
You want memory as plain files in your own git repository that a person can read, edit and revert, without a structured belief model.
You want the agent itself in Slack, Telegram or Discord.
Your problem is one agent's working memory, not a person's or a business's knowledge across many tools. Confidence, decay and audience would then be machinery you do not need.
Letta's pricing page, read September 22, 2026 and carrying no date of its own, lists Free at $0 with 3 agents, Pro at $20 a month for up to 20 agents, an API plan at $20 a month plus usage, Teams Pro at $20 per seat a month, and a custom Enterprise plan.
Where Letta is ahead
Openness. Both Letta repositories are Apache 2.0, and the harness runs with your own model keys.
Readable, reversible memory. Every memory change is a git commit with an author, so you can read the history and revert. thinqOS records changes in an event log, but its readable form is an export, and we found no control in the thinqOS app to undo one change.
Learning that changes behavior. Letta's reflection puts mistakes and corrections first, and can turn repeated workflows into skills. thinqOS stores lessons and procedures, but its learning from outcomes is partial.
A review step. Letta Code has an optional mode in which the agent reviews memory changes before they apply.
Memory size tools. Letta Code has commands that show how much of the prompt memory takes up and where it has grown.
Choice of model. The retired server had client code for 20 model providers, and Letta Code lets you switch models during a session.
Where thinqOS is ahead
Each point below is in thinqOS's code and running today.
Confidence as data. Every belief has a confidence value that blends new evidence with old, and a stated belief outranks an inferred one. We found no confidence value in Letta's memory code.
Salience kept apart from truth. Salience decays over time and rises with use. Protected beliefs have a floor, and unprotected ones that fall low enough are archived. In Letta, the agent decides by hand which files stay in its prompt.
Consolidation that keeps evidence. A summary belief is capped at 0.85 confidence and at the average of its sources, the sources are kept, and its audience is limited to what all its sources allowed. Letta's reflection rewrites prose, and the evidence it summarized is not kept alongside.
Provenance. Changes to a Mind are recorded in an append-only event log with their source. Letta's git and block history show what changed, not which source produced a fact.
Audience per belief, enforced at recall. In Letta, what an agent holds it can tell anyone it talks to.
One Mind across tools. thinqOS runs an MCP server and captures work from Claude Code, Codex, VS Code Copilot, Cline and Grok Build. It also connects to ChatGPT and Claude.ai. Letta uses MCP only as a client, and we found no way for another tool to reach a Letta agent's memory.
Inspection. The thinqOS app shows a Mind's beliefs, sources and conflicts, and each answer in the app has an "Explain this response" view.
What is partial in thinqOS
Choosing what reaches the context window is still being built, goal pursuit is largely unbuilt, and learning from outcomes is partial. The contradiction check runs when a belief is confirmed, stated directly or resolved, not in the background. The event log does not yet record every kind of change. Retracting a belief does not delete it, and a full reprocessing of a Mind can bring a corrected belief back; the code detects that case. Plain ChatGPT and Claude.ai chats have no hooks, so how often they call thinqOS unprompted has not been measured.
Choose thinqOS when
Choose thinqOS when you, or a business owner, want one Mind that follows you across Claude Code, Codex and the chat tools it connects to, with beliefs that carry confidence, provenance, decay and an audience, and where you can see and correct what is believed and why. A Letta agent could in principle call thinqOS as an MCP tool; we have not seen that built.