Vilix AI vs Letta: Which Memory Approach Fits Your AI Agents?

The short answer: Vilix AI and Letta both give AI agents persistent memory, but they live in different places. Letta is an open-source agent harness where the agent curates its own memory as versioned files you run locally with your own model keys. Vilix AI is a cloud-hosted shared memory layer you attach over MCP to tools you didn't build (Claude, Codex, n8n agents, headless runners), one memory across all of them. The honest tradeoff: Vilix AI is cloud-only; Letta is self-hosted and you run the whole stack.

What is Letta?

Letta is the team behind MemGPT, the paper that framed an LLM as an operating system: the context window as RAM, an external store as disk. That idea is still the core of the product, but the implementation changed in 2026.

In March 2026 Letta refocused on Letta Code, a model-agnostic agent harness, and moved memory into what it calls context repositories: git-backed files the agent edits with ordinary file tools, instead of specialized tools editing rows in a database. The older server-side machinery (core_memory_replace, the Letta Filesystem, server-side MCP integrations, server-side sleep-time agents, tool rules) was deprecated in favor of client-side equivalents, and the V1 API server now lives on an archive branch with active development in the letta-code repository. If you built on the old server API, you should know the product is mid-transition.

The design bet is real and worth understanding: when the agent rewrites its own memory, the edit is a git diff. Every memory change is reviewable, revertable, and auditable with tools your platform team already runs. An auditor can be shown the git history of what the agent believed and when it changed its mind, without anyone building a memory-provenance feature. On benchmarks, Letta takes an unusual stance: it published 74.0% on LoCoMo with agents storing conversation histories in plain files, then argued the benchmark is a weak proxy for real context management, and now runs its own Context-Bench evaluations instead. It publishes no latency numbers and advertises no SOC 2 or HIPAA certification; its compliance answer is that you run it, on your own keys, on your own machine or server.

What is Vilix AI?

Vilix AI is a cloud-hosted shared memory and work-state layer across MCP clients, tied to one Vilix AI account. Connect each AI tool once (OAuth, or an API key as Bearer token to https://api.vilix.ai/mcp for headless agents like Hermes or OpenClaw), enable the memory tools, and the same memory follows you across tools: Claude, Codex, Cursor, OpenClaw, Hermes, Grok, Manus AI, GitHub Copilot, Windsurf, Lovable, Muse, any MCP-compatible AI. It stores full conversation exchanges with source metadata, derived memories, projects, tasks, rules, reusable agent skills, and an agent inbox, all editable from any connected tool or the dashboard at app.vilix.ai.

The real question is the same one as with every memory product: are you building agents, or are you operating them? Letta is a harness you build agents inside of. Vilix AI is a layer attached to tools you didn't build.

How do Vilix AI and Letta compare head to head?

Letta facts: particula.tech's September 2026 framework comparison plus Letta's public docs and repo state, read September 2026. Vilix AI facts: product truth sheet. Prices and product details change; verify both pricing pages.

Where does Letta win?

1. The agent curates its own memory. There is no separate extraction pipeline deciding what is worth keeping. The agent writes what it needs into its context files and rewrites them as things change. If you have watched an extraction pass quietly drop the one detail that mattered, handing the curation job to the agent is a principled answer.
2. Memory as git diffs. Every memory edit is versioned, reviewable, and revertable with standard tooling. For teams that already run git-based review workflows, this is a genuine audit property that no managed memory service offers: the full history of what the agent believed, diff by diff.
3. Local-first and open source. You run the harness on your own machine or server with your own model keys. Data never leaves your perimeter, and the whole harness is open source, not just a library. If self-hosting is a requirement rather than a preference, this is the decisive column.
4. The MemGPT lineage. The OS metaphor (context as RAM, archival store as disk) shaped how the whole industry thinks about agent memory. Betting on the team that wrote the paper is a defensible bet.

Where does Vilix AI win?

1. One memory across every tool, not one runtime. Letta's memory lives inside the agents built in its harness. The operator pain is the opposite: a scheduled agent in n8n, a coding session in Claude Code, planning on your phone, each waking up with amnesia. Vilix AI is a single shared memory over MCP that follows you across tools you didn't build. You brief one tool once; the rest pull from the same memory.
2. Full conversations, not agent-curated files. When the agent is the curator, what it chose not to write down is gone. Vilix AI stores the actual full exchanges with source metadata, so you can revisit the real conversation anytime. When an operator needs to know what their agent actually did on last night's scheduled run, not just what the agent decided was worth recording, full history is more faithful.
3. Zero infrastructure. Running Letta means running the stack: the harness, your model keys, your machine or server. Vilix AI is cloud-hosted: you manage nothing. That is the stated pitch up front, because operators always ask "local or cloud?" and the answer here is cloud.
4. Pricing built for operators. Self-hosting Letta is free in license cost but you pay in infrastructure and upkeep. Vilix AI is flat: Starter $10/mo, Pro $20/mo, Power $49/mo, with a free plan and a 7-day Pro trial that needs no credit card. For a scheduled agent that fires hundreds of times a day, flat pricing is easy to reason about.

The honest tradeoff

Vilix AI is cloud-only: no self-host option, no open-source server. If data residency inside your own perimeter or running your own stack is a hard requirement, Letta wins outright and the comparison ends there.

The counterweight: your data is portable. Export everything in a portable format anytime, delete individual memories or wipe the account instantly, with per-user isolation and no training of third-party models on your memory. Portability is not the same as self-hosting, so weigh it accordingly.

And a concession the other way: Letta's product is mid-transition. The March 2026 refocus deprecated a meaningful chunk of the server-side machinery, and the V1 API sits on an archive branch. If you are evaluating it, evaluate Letta Code and the context-repository model as they exist today, not the server product the older comparisons describe. Vilix AI stores full conversations with recency-aware retrieval (last write wins), which is simpler than agent-curated memory, but it does not give you git-diff auditability of every memory edit.

Which should you pick?

• Pick Letta if you are building agents inside its harness and want the agent to curate its own memory, if local-first execution with your own model keys is a requirement, or if you want memory edits reviewable as git diffs and the whole stack open source.
• Pick Vilix AI if you operate agents across tools you didn't build (scheduled n8n runs, Claude Code sessions, headless agents), want full conversation history instead of agent-curated files, and would rather manage zero infrastructure at flat pricing.

If you want to try the shared-memory model, Vilix AI starts with a free plan and a 7-day Pro trial with no credit card. Leave with your data whenever you want: export everything or delete it anytime in a portable format.