Mem0 vs Letta

Agent access

1. ai-native userPoint an agent at llms.txt or agent-oriented docs

   weight 2 · round to Mem0
   Mem0✓fullprobed9/10

   A probe confirms docs.mem0.ai/llms.txt returns HTTP 200 with a proper agent-oriented summary of Mem0, and the docs also expose an OpenAPI spec, MCP server, and CLI that an agent can consume directly. Missing for 10: independent/community confirmation that an agent successfully used llms.txt in practice.

   • [probe] “PROBE llms.txt: HTTP 200 at https://docs.mem0.ai/llms.txt # Mem0 > Mem0 is a memory layer for LLM agents - persistent, self-improving conte…”
   • [probe] “PROBE openapi: HTTP 200 at https://docs.mem0.ai/openapi.json — contains "openapi" key”
   • [probe] “official MCP server documented at https://docs.mem0.ai/platform/mem0-mcp”
   • [probe] “official CLI documented at https://docs.mem0.ai/platform/cli”

   proof ↗⚑ flag

   Letta✓fullprobed8/10

   A direct probe confirms Letta publishes an llms.txt file at docs.letta.com/llms.txt returning HTTP 200 with agent-oriented summary content, and Letta's extensive docs site is clearly structured for programmatic/agent consumption (agent-sdk, CLI, MCP docs). Missing for 10: no evidence of llms.txt content depth/comprehensiveness or independent confirmation that agents successfully consume it in practice.

   • [probe] “PROBE llms.txt: HTTP 200 at https://docs.letta.com/llms.txt # Letta > Letta agents learn from experience and improve with use. The Letta ag…”
   • [claimed-docs] “create an agent once, then resume it from anywhere”

   proof ↗⚑ flag

2. ai-native userRun the product headlessly / in CI for automation

   weight 2 · round drawn
   Mem0✓fullprobed8/10

   Mem0 is fundamentally API/SDK-first and documents non-interactive setup: a terminal-only account/API-key flow explicitly designed for coding agents with no email or dashboard, a CLI for add/search/list/update/delete, and a self-hostable Docker/REST stack with API keys and audit logs — all of which are naturally scriptable in CI. missing for 10: an explicit CI/CD pipeline example or GitHub Actions integration doc, and independent (non-vendor) confirmation of headless CI usage.

   • [claimed-docs] “a coding agent creates its own account from the terminal and starts storing memories immediately”
   • [claimed-docs] “a coding agent creates its own account from the terminal and starts storing memories immediately.”
   • [claimed-docs] “Let an AI agent create its own Mem0 account and API key in four commands, with no email or dashboard needed.”
   • [claimed-docs] “Four terminal commands create an account and API key. No email, no dashboard.”
   • [claimed-docs] “The mem0 CLI lets you add, search, list, update, and delete memories directly from the terminal.”
   • [claimed-docs] “lets you add, search, list, update, and delete memories directly from the terminal”
   • [claimed-docs] “Self-host Mem0 with full control over your infrastructure and data”
   • [claimed-docs] “A Docker stack with a dashboard, per-user API keys, and a request audit log.”
   • [claimed-docs] “As a self-hosted server. A Docker stack with a dashboard, per-user API keys, and a request audit log.”
   • [probe] “PROBE openapi: HTTP 200 at https://docs.mem0.ai/openapi.json — contains "openapi" key”

   proof ↗⚑ flag

   Letta✓fullclaimed8/10

   Letta explicitly documents a headless CLI mode built for non-interactive use in scripts, CI/CD pipelines, and UNIX tool composition, plus an --ephemeral one-shot flag for stateless CI runs, backed by a self-hostable App Server and SDK for programmatic/automated invocation. Missing for 10: independent hands-on CI usage report or example CI config demonstrating it in practice.

   • [claimed-docs] “Headless mode allows you to run Letta Code non-interactively, making it easy to integrate into scripts, CI/CD pipelines, or compose with oth…”
   • [claimed-docs] “Headless mode allows you to run Letta Code non-interactively, making it easy to integrate into scripts, CI/CD pipelines, or compose with oth…”
   • [claimed-docs] “Use --ephemeral to run a one-shot task without creating, resuming, or persisting an agent, memory blocks, or MemFS”
   • [claimed-docs] “Headless mode allows you to run Letta Code non-interactively, making it easy to integrate into scripts, CI/CD pipelines”
   • [claimed-docs] “The Letta App Server lets you deploy the Letta agent harness as a service.”
   • [claimed-docs] “Use `backend: "cloud"` to host agents in Letta Cloud and run tools in managed cloud environments.”

   proof ↗⚑ flag

3. ai-native userUse an official CLI

   weight 2 · round drawn
   Mem0✓fullprobed8/10

   Mem0 documents an official CLI that lets users add, search, list, update, and delete memories directly from the terminal, explicitly for both humans and AI agents, plus a related agent-signup flow via terminal commands. missing for 10: independent/hands-on verification of the CLI beyond vendor docs, and more detail on CLI command coverage/versioning.

   • [claimed-docs] “The mem0 CLI lets you add, search, list, update, and delete memories directly from the terminal.”
   • [claimed-docs] “lets you add, search, list, update, and delete memories directly from the terminal”
   • [claimed-docs] “The mem0 CLI lets you add, search, list, update, and delete memories directly from the terminal. It works with the Mem0 Platfor”
   • [claimed-docs] “Manage memories from your terminal, for both humans and AI agents.”
   • [claimed-docs] “Let an AI agent create its own Mem0 account and API key in four commands, with no email or dashboard needed.”
   • [probe] “official CLI documented at https://docs.mem0.ai/platform/cli”

   proof ↗⚑ flag

   Letta✓fullprobed8/10

   Letta ships an official CLI ("Letta Code") with rich documentation covering interactive slash commands, headless/non-interactive scripting mode for CI/CD, local/self-hosted mode, and cloud sync — confirmed by first-party docs and a probe hitting the CLI docs page directly. Community evidence (HN threads with Letta employees) corroborates real usage of CLI features like --yolo mode and /init, indicating it's a genuine, actively used tool. Missing for 10: independent hands-on reviews specifically benchmarking the CLI's reliability/UX beyond employee-provided community threads, and no direct evidence of install/version metrics or broad third-party adoption data.

   • [claimed-docs] “Headless mode allows you to run Letta Code non-interactively, making it easy to integrate into scripts, CI/CD pipelines, or compose with oth…”
   • [claimed-docs] “Headless mode allows you to run Letta Code non-interactively, making it easy to integrate into scripts, CI/CD pipelines, or compose with oth…”
   • [claimed-docs] “This default local mode stores agent state on your machine and does not require a Letta login.”
   • [claimed-docs] “Control Letta Code's behavior during an interactive session with slash commands.”
   • [claimed-docs] “Run /login to back up your agents to the cloud and make them available through chat.letta.com, the desktop app, remote machines, and messagi…”
   • [probe] “official CLI documented at https://docs.letta.com/platform/cli”
   • [community] “Letta Code described by Letta's Charles as 'memory-first': agents build learned context over time via tools like /init and /remember; a /cle…”
   • [community] “User asks if Letta Code supports a 'yolo'/dangerous-skip-permissions mode like Claude Code; Letta's Charles confirms: 'Letta Code also has a…”
   • [community] “Letta employee describes Letta Code: 'a fundamentally different approach to coding agents with a focus on continual learning and statefulnes…”

   proof ↗⚑ flag

4. ai-native userDrive the product through a documented public API

   weight 3 · round to Mem0
   Mem0✓fullprobed9/10

   Mem0 provides a well-documented REST/SDK API (openapi.json confirmed live, quickstart with Python/JS SDKs, add/search operations), plus a CLI and MCP server enabling agents to programmatically create accounts and drive memory operations without human intervention. Coverage spans platform and self-hosted API surfaces with concrete request/response examples. Missing for 10: independent third-party benchmark or hands-on verification of API robustness beyond vendor docs.

   • [claimed-docs] “In about five minutes you will get an API key, store your first memory, and search it back.”
   • [claimed-docs] “get an API key, then save and search a memory in Python or JavaScript”
   • [claimed-docs] “client.add(messages, user_id="user123")”
   • [claimed-docs] “a coding agent creates its own account from the terminal and starts storing memories immediately.”
   • [claimed-docs] “Let an AI agent create its own Mem0 account and API key in four commands, with no email or dashboard needed.”
   • [probe] “PROBE openapi: HTTP 200 at https://docs.mem0.ai/openapi.json — contains "openapi" key”
   • [probe] “official MCP server documented at https://docs.mem0.ai/platform/mem0-mcp”
   • [probe] “official CLI documented at https://docs.mem0.ai/platform/cli”
   • [claimed-docs] “The mem0 CLI lets you add, search, list, update, and delete memories directly from the terminal.”

   proof ↗⚑ flag

   Letta✓fullprobed8/10

   Letta ships a fully documented Agent SDK (TypeScript, with browser/mobile variants) covering agent creation, sessions, streaming, permissions, MCP tool proxying, and an OpenAI-compatible App Server API, all backed by extensive first-party docs and a public GitHub SDK repo. This clearly satisfies driving the product programmatically as an AI-native user via a documented public API. missing for 10: a discoverable formal OpenAPI/swagger spec (probe found only 404s), and independent/hands-on developer corroboration of the SDK's public API stability.

   • [claimed-docs] “Create a stateful agent with `client.createAgent()`. It returns the agent's ID as a string, which you use to open sessions and manage the ag…”
   • [claimed-docs] “The stream yields typed events for the whole turn — reasoning, assistant text, tool calls, tool results”
   • [claimed-docs] “a **`canUseTool` callback** that approves, denies, or edits individual tool calls — interactively, if your application involves a human.”
   • [claimed-docs] “`resumeSession(id)` accepts either kind of ID: pass an `agent-xxx` ID to resume the agent's default conversation, or a `conv-xxx` ID to resu…”
   • [claimed-docs] “The stream yields typed events for the whole turn — reasoning, assistant text, tool calls, tool results — and terminates after the turn's `r…”
   • [claimed-docs] “The SDK supports local stdio processes, Streamable HTTP, and legacy SSE”
   • [claimed-docs] “MCP tools are discovered from servers supplied through `mcpServers` and proxied by the SDK host to the MCP server.”
   • [claimed-docs] “Send a message with `session.send()` and read the response with `session.stream()`. The stream yields typed events for the whole turn”
   • [claimed-docs] “use the App Server’s OpenAI-compatible API with clients such as Open WebUI, or the ACP adapter with ACP clients such as Zed”
   • [github] “the Letta Agent SDK for building agents into TypeScript applications”
   • [probe] “PROBE openapi: all candidate paths 404 (https://docs.letta.com/openapi.json, https://docs.letta.com/swagger.json, https://docs.letta.com/api…”

   proof ↗⚑ flag

5. ai-native userIssue scoped/least-privilege API credentials for an agent

   weight 2 · round to Mem0
   Mem0~partialclaimed5/10

   Mem0 supports per-user/agent API keys and lets an agent self-provision its own account and key via CLI, plus entity-scoped memory (user_id/agent_id/app_id/session_id) to isolate data access, which gives some least-privilege-like scoping. However there is no documented fine-grained permission model (e.g., read-only vs write, scope restrictions per key) beyond per-user key issuance and an audit log. Missing for 10: explicit permission/scope levels on API keys, revocation/rotation controls, and independent verification of least-privilege enforcement.

   • [claimed-docs] “a coding agent creates its own account from the terminal and starts storing memories immediately”
   • [claimed-docs] “a coding agent creates its own account from the terminal and starts storing memories immediately.”
   • [claimed-docs] “Let an AI agent create its own Mem0 account and API key in four commands, with no email or dashboard needed.”
   • [claimed-docs] “The self-hosted bundle ships the REST API and a web dashboard together... per-user API keys and a request audit log.”
   • [claimed-docs] “A Docker stack with a dashboard, per-user API keys, and a request audit log.”
   • [claimed-docs] “Mem0's Platform API lets you separate memories for different users, agents, and apps.”
   • [claimed-docs] “Scope conversations by user, agent, app, and session so memories land exactly where they belong.”
   • [claimed-docs] “Stand up the Mem0 REST server and dashboard in a few minutes, with an admin account, API keys, and a live audit log included.”

   proof ↗⚑ flag

   Letta~partialclaimed4/10

   Letta offers some related scoped-access mechanisms — Secrets that let an agent use API keys/tokens without ever seeing the raw values, GitHub integration where agents can only access repositories explicitly granted, and tool/action permission modes (unrestricted/acceptEdits/standard, canUseTool callback) — but there's no documented mechanism for issuing a distinct, scoped/least-privilege API credential specifically for an agent's own access to the Letta API or external services. missing for 10: explicit per-agent API key/credential issuance with configurable scopes, documentation of least-privilege credential lifecycle (rotation/revocation), and independent confirmation of scoped-credential behavior in practice.

   • [claimed-docs] “Secrets let your agent use sensitive values like API keys and tokens in shell commands without ever seeing the actual values.”
   • [claimed-docs] “Once connected, agents in your Letta org running on cloud computers will be able to clone, read, and push to the repositories you grant acce…”
   • [claimed-docs] “Press `Shift+Tab` in interactive mode to cycle through `unrestricted`, `acceptEdits`, and `standard`.”
   • [claimed-docs] “a **`canUseTool` callback** that approves, denies, or edits individual tool calls — interactively, if your application involves a human.”
   • [claimed-docs] “You can share agents across your team (and set permissions for access) to create custom agents for your organization”

   proof ↗⚑ flag

6. ai-native userBuild against official SDKs

   weight 2 · round drawn
   Mem0✓fullprobed8/10

   Mem0 provides official Python/JavaScript SDKs with quickstart docs, an OpenAPI-backed REST API, and documented setup guides for 22+ frameworks (LangChain, CrewAI, LlamaIndex, Vercel AI SDK), all core to AI-native agentic workflows. Missing for 10: independent hands-on developer reviews specifically validating SDK ergonomics/reliability beyond vendor docs.

   • [claimed-docs] “In about five minutes you will get an API key, store your first memory, and search it back.”
   • [claimed-docs] “Setup guides for 22 tools, including LangChain, CrewAI, LlamaIndex, and the Vercel AI SDK.”
   • [claimed-docs] “get an API key, then save and search a memory in Python or JavaScript”
   • [claimed-docs] “client.add(messages, user_id="user123")”
   • [claimed-docs] “Set up your Mem0 Platform account, install the SDK, and store your first memory in under five minutes.”
   • [probe] “PROBE openapi: HTTP 200 at https://docs.mem0.ai/openapi.json — contains "openapi" key”

   proof ↗⚑ flag

   Letta✓fullclaimed8/10

   Letta ships an official Agent SDK (letta-ai/letta on GitHub, TypeScript) with extensive first-party documentation covering agent creation, sessions, streaming, MCP tool integration, permissions/canUseTool callbacks, cloud/self-host deployment options, and demo apps for browser, Expo/React Native, and desktop clients - a substantial, well-documented SDK surface for AI-native builders. Missing for 10: independent hands-on developer reviews/benchmarks of the SDK itself, and evidence of official SDKs beyond TypeScript (e.g., Python).

   • [github] “the Letta Agent SDK for building agents into TypeScript applications”
   • [claimed-docs] “Create a stateful agent with `client.createAgent()`. It returns the agent's ID as a string, which you use to open sessions and manage the ag…”
   • [claimed-docs] “The stream yields typed events for the whole turn — reasoning, assistant text, tool calls, tool results”
   • [claimed-docs] “a **`canUseTool` callback** that approves, denies, or edits individual tool calls — interactively, if your application involves a human.”
   • [claimed-docs] “Browser, Expo, and React Native applications must import the SDK from `@letta-ai/letta-agent-sdk/client`”
   • [claimed-docs] “Use `backend: "cloud"` to host agents in Letta Cloud and run tools in managed cloud environments.”
   • [claimed-docs] “`resumeSession(id)` accepts either kind of ID: pass an `agent-xxx` ID to resume the agent's default conversation, or a `conv-xxx` ID to resu…”
   • [claimed-docs] “The SDK supports local stdio processes, Streamable HTTP, and legacy SSE”
   • [claimed-docs] “MCP tools are discovered from servers supplied through `mcpServers` and proxied by the SDK host to the MCP server.”
   • [claimed-docs] “Send a message with `session.send()` and read the response with `session.stream()`. The stream yields typed events for the whole turn”
   • [claimed-docs] “a complete Expo and React Native client for persistent Letta agents”

   proof ↗⚑ flag

7. ai-native userSubscribe to events via webhooks

   weight 2 · round to Mem0
   Mem0✓fullclaimed8/10

   Mem0 documents webhooks explicitly, letting users configure HTTP POST callbacks for memory created/updated/deleted/categorized events, which is exactly a webhook subscription mechanism for agentic event-driven workflows. Missing for 10: no independent/hands-on corroboration of webhook reliability and no detail on payload schema or retry/security guarantees.

   • [claimed-docs] “Webhooks enable real-time notifications for memory events in your Mem0 project.”
   • [claimed-docs] “You can configure webhooks to send HTTP POST requests to your specified URLs whenever memories are created, updated, deleted, or categorized…”
   • [claimed-docs] “Configure and manage webhooks to receive real-time notifications about memory events”
   • [claimed-docs] “Webhooks enable real-time notifications for memory events in your Mem0 projec”

   proof ↗⚑ flag

   Letta—none0/10

   The evidence pack covers agent SDK streaming, subagents, mods, scheduled tasks, and Slack/GitHub integrations, but there is no mention of a webhook subscription mechanism for events (e.g., agent state changes, task completion) that external systems could subscribe to. Streaming responses (letta-docs-43, letta-docs-60) are pull-based within an active session, not webhook push notifications.

   ⚑ flag

Agentic features

1. ai-native userGet AI-generated insights and suggestions from my data inside the product

   weight 2 · round to Letta
   Mem0~partialclaimed4/10

   Mem0 automatically extracts facts from conversations and builds a graph linking people, places, and concepts, and reranks results by semantic relevance — these are forms of AI-generated structuring of raw data, but there is no documented feature that proactively surfaces 'insights' or 'suggestions' to the end user (e.g., a dashboard summary or recommendation engine); the product is positioned as memory storage/retrieval infrastructure for agents rather than an insight-generation tool. missing for 10: explicit insights/suggestions surfacing feature, evidence of proactive recommendations, independent corroboration that graph connections are presented as user-facing insights.

   • [claimed-docs] “Mem0 pulls the individual facts out of the conversation and stores each one separately”
   • [claimed-docs] “Mem0 Platform builds a native graph linking people, places, and concepts across your memories, with no external graph database to provision.”
   • [claimed-docs] “Mem0 Platform builds a native graph linking people, places, and concepts across your memories”
   • [claimed-docs] “Reorders results using deep semantic understanding to put the most relevant memories first.”
   • [claimed-docs] “You ask entity-centric questions like "what do we know about Alice?" and expect facts pulled from many different conversations”

   proof ↗⚑ flag

   Letta~partialcommunity6/10

   Letta's 'dreaming' feature uses background subagents to review conversation history and consolidate learned lessons into memory without interrupting the user, and /doctor audits memory placement/duplication — both are forms of AI-generated insight derived from the agent's own interaction data. However, these are framed as internal memory-maintenance mechanisms rather than explicit user-facing 'suggestions' or dashboards surfacing insights about the user's data, and there is no independent/hands-on evidence of the quality of these generated insights. Missing for 10: user-facing insight/suggestion UI or reports, independent verification that dreaming produces useful proactive suggestions, and examples of insights derived from arbitrary connected data sources (not just conversation history).

   • [claimed-docs] “Dreaming uses background subagents to review recent conversations, consolidate useful lessons, and update memory without interrupting your a…”
   • [claimed-docs] “trigger controls when dreaming runs: after a number of steps, on context compaction, or never.”
   • [claimed-docs] “If the memory hierarchy has drifted or grown too large, run /doctor to audit placement, duplication, and system-prompt token usage.”
   • [claimed-docs] “You can also teach it explicitly with /remember: > /remember always use pnpm in this repo”
   • [community] “Letta Code described by Letta's Charles as 'memory-first': agents build learned context over time via tools like /init and /remember; a /cle…”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the [MemFS Search mod]”

   proof ↗⚑ flag

2. ai-native userOperate the product with natural-language commands

   weight 2 · round to Letta
   Mem0~partialclaimed6/10

   Mem0 supports natural-language queries for its 'search' operation and exposes memory tools via MCP so an agent can decide in natural language when to save/retrieve/update memories, which covers the core NL-driven interaction pattern. However, other operations (add, update, delete, CLI commands) are structured API/CLI calls rather than free-form natural-language commands, so full conversational control of the product isn't evidenced. Missing for 10: a unified NL command interface covering all memory operations (not just search), and independent hands-on evidence of agents operating purely via natural language.

   • [claimed-docs] “Mem0's search operation lets agents ask natural-language questions and get back the memories that matter most.”
   • [claimed-docs] “Mem0's search operation lets agents”
   • [claimed-docs] “The Mem0 MCP server hands your agent a set of memory tools, so it can decide for itself when to save something, look something up, or update…”
   • [claimed-docs] “lets you add, search, list, update, and delete memories directly from the terminal”
   • [claimed-docs] “Manage memories from your terminal, for both humans and AI agents.”

   proof ↗⚑ flag

   Letta✓fullcommunity8/10

   Letta Code and CLI are extensively controlled via natural-language chat plus slash commands (/remember, /init, /fork, /btw, /doctor, /agents) that wrap agent behavior in conversational form, and agents themselves interpret natural-language instructions to manage memory, tools, and subagents. missing for 10: independent hands-on evidence (beyond vendor docs/HN Q&A) confirming reliability of natural-language command interpretation across complex workflows.

   • [claimed-docs] “Control Letta Code's behavior during an interactive session with slash commands.”
   • [claimed-docs] “Run `/init` to bootstrap or refresh memory for the current project. The agent inspects the repository, asks about your working style when ne…”
   • [claimed-docs] “You can also teach it explicitly with `/remember`: `> /remember always use pnpm in this repo`. The agent decides where the lesson belongs an…”
   • [claimed-docs] “You can also teach it explicitly with /remember: > /remember always use pnpm in this repo”
   • [claimed-docs] “If the memory hierarchy has drifted or grown too large, run /doctor to audit placement, duplication, and system-prompt token usage.”
   • [claimed-docs] “Use /fork to branch the current conversation, including its in-context history. The new conversation can take a different direction without …”
   • [claimed-docs] “Use /btw for a side question. It forks the conversation in the background and returns the answer without interrupting your main task”
   • [community] “Letta Code described by Letta's Charles as 'memory-first': agents build learned context over time via tools like /init and /remember; a /cle…”
   • [community] “User asks if Letta Code supports a 'yolo'/dangerous-skip-permissions mode like Claude Code; Letta's Charles confirms: 'Letta Code also has a…”

   proof ↗⚑ flag

Api quality

1. ai-native userExplore an interactive API reference with runnable examples

   weight 2 · round to Mem0
   Mem0~partialprobed4/10

   An OpenAPI spec is exposed (mem0-probe-2) and quickstart docs include copyable Python/JS code snippets for add/search calls (mem0-docs-25, mem0-docs-35), which is consistent with an API reference, but there is no evidence of an interactive, in-browser 'try it now' console or runnable-example sandbox tied to that OpenAPI spec. Missing for 10: explicit interactive API explorer/playground UI, evidence of live request execution from docs, and independent confirmation that examples are runnable rather than just illustrative code blocks.

   • [probe] “PROBE openapi: HTTP 200 at https://docs.mem0.ai/openapi.json — contains "openapi" key”
   • [claimed-docs] “get an API key, then save and search a memory in Python or JavaScript”
   • [claimed-docs] “client.add(messages, user_id="user123")”
   • [claimed-docs] “Set up your Mem0 Platform account, install the SDK, and store your first memory in under five minutes.”

   proof ↗⚑ flag

   Letta—none0/10

   The evidence pack shows extensive SDK documentation (agent-sdk pages) but no interactive API reference or runnable-example explorer; a direct probe for OpenAPI/Swagger endpoints returned 404 on all candidate paths, indicating no such interactive reference exists.

   • [probe] “PROBE openapi: all candidate paths 404 (https://docs.letta.com/openapi.json, https://docs.letta.com/swagger.json, https://docs.letta.com/api…”

   proof ↗⚑ flag

2. ai-native userDownload a machine-readable API spec (OpenAPI or equivalent)

   weight 2 · round to Mem0
   Mem0✓fullprobed9/10

   A direct probe confirms https://docs.mem0.ai/openapi.json returns HTTP 200 and contains an 'openapi' key, i.e. a machine-readable OpenAPI spec is downloadable, and the API is documented elsewhere for developers. Missing for 10: no explicit vendor-side documentation page linking/describing the spec's versioning or completeness beyond the raw probe.

   • [probe] “PROBE openapi: HTTP 200 at https://docs.mem0.ai/openapi.json — contains "openapi" key”
   • [claimed-docs] “In about five minutes you will get an API key, store your first memory, and search it back.”
   • [claimed-docs] “get an API key, then save and search a memory in Python or JavaScript”

   proof ↗⚑ flag

   Letta—none0/10

   Direct probes for OpenAPI/Swagger specs at all standard paths (docs.letta.com/openapi.json, swagger.json, api/openapi.json, .well-known/openapi.json) returned 404, and no documentation elsewhere in the evidence pack references a downloadable machine-readable API spec.

   • [probe] “PROBE openapi: all candidate paths 404 (https://docs.letta.com/openapi.json, https://docs.letta.com/swagger.json, https://docs.letta.com/api…”

   proof ↗⚑ flag

3. ai-native userTest against a sandbox environment without touching production data

   weight 1 · round to Letta
   Mem0—none0/10

   No evidence pack items mention a sandbox, staging, or test-mode environment distinct from production for Mem0's Platform API; self-hosting (mem0-docs-4, mem0-docs-21) offers infrastructure control but is not described as a sandbox/test environment feature. This is a fair capability to expect from an API-based memory platform, but nothing in the docs or community evidence documents it.

   ⚑ flag

   Letta~partialclaimed4/10

   Letta offers isolation-oriented options that could support sandbox-style testing: an --ephemeral CLI mode that runs one-shot tasks without persisting any agent, memory, or MemFS state (letta-docs-14), and a managed 'cloud sandbox' for running agents with no local setup (letta-docs-16, letta-docs-33, letta-docs-58). However, there is no explicit documentation of a staging/production environment separation or guarantee that testing won't touch production agent data. Missing for 10: explicit staging-vs-production environment concept, documentation of data isolation guarantees, and any evidence/testimonial confirming this workflow is used for safe testing.

   • [claimed-docs] “Use --ephemeral to run a one-shot task without creating, resuming, or persisting an agent, memory blocks, or MemFS”
   • [claimed-docs] “The desktop app and CLI can use your existing API keys and coding plans, while the web app runs agents in a cloud sandbox with no local setu…”
   • [claimed-docs] “The web app uses a managed cloud sandbox by default, so you can start without configuring a computer.”
   • [claimed-docs] “the web app runs agents in a cloud sandbox with no local setup”

   proof ↗⚑ flag

4. ai-native userRely on versioned APIs with a documented deprecation policy

   weight 2 · round drawn
   Mem0—none0/10

   The evidence pack shows quickstart docs, an OpenAPI spec, and various feature docs, but nothing about API versioning scheme or a documented deprecation policy. No changelog, version headers, or deprecation notices are mentioned anywhere in the pack.

   ⚑ flag

   Letta—none0/10

   No evidence anywhere in the pack of API versioning schemes or a documented deprecation policy; the openapi.json probe even 404s, indicating no discoverable API spec that would carry version/deprecation info.

   • [probe] “PROBE openapi: all candidate paths 404 (https://docs.letta.com/openapi.json, https://docs.letta.com/swagger.json, https://docs.letta.com/api…”

   proof ↗⚑ flag

1. ai-native userPerform bulk operations across many items at once

   weight 2 · round to Letta
   Mem0~partialclaimed3/10

   Mem0's CLI and API document per-item add/search/list/update/delete, and the Memory Export feature lets users pull structured exports of memories at once, which is the closest evidence to a bulk operation, but there is no documented batch-add, bulk-delete, or multi-item transactional endpoint. missing for 10: explicit batch/bulk add or delete API, documented multi-item transaction support, evidence of performance/testing at scale for bulk operations.

   • [claimed-docs] “The Memory Export feature allows you to create structured exports of memories using customizable Pydantic schemas.”
   • [claimed-docs] “create structured exports of memories using customizable Pydantic schemas”
   • [claimed-docs] “lets you add, search, list, update, and delete memories directly from the terminal”
   • [claimed-docs] “The mem0 CLI lets you add, search, list, update, and delete memories directly from the terminal.”

   proof ↗⚑ flag

   Letta~partialclaimed4/10

   Letta offers some multi-item automation primitives — subagents for parallel task delegation ('divide and conquer tasks') and a cross-agent `/search` command that queries across all agents at once — which support limited bulk-style operations, but there is no documented bulk API for batch-creating, editing, importing/exporting, or mass-updating agents, memory blocks, or files. Missing for 10: explicit bulk CRUD/batch APIs, bulk import/export tooling, and evidence of large-scale multi-item operations beyond parallel subagent delegation and cross-agent search.

   • [claimed-docs] “By delegating work to focused subagents, your main agent can keep its context window clean and make use of parallelism to divide and conquer…”
   • [claimed-docs] “Subagents are specialized agents that your main agent can spawn to handle complex tasks autonomously.”
   • [claimed-docs] “`/search [query]` | Search messages across agents”
   • [claimed-docs] “Up to 20 stateful agents”
   • [claimed-docs] “With a developer plan, you can create an unlimited number of agents but pay usage-based pricing.”

   proof ↗⚑ flag

2. ai-native userDefine rules that trigger actions automatically on events

   weight 3 · round to Letta
   Mem0~partialclaimed4/10

   Mem0's webhooks let external systems receive real-time HTTP POST notifications when memories are created, updated, deleted, or categorized, which is the closest thing to event-driven automation — but this is a fixed notification hook, not a user-defined 'rules engine' that lets AI-native users specify custom conditions/actions to trigger. Missing for 10: no evidence of a rules/conditions builder, no support for arbitrary trigger logic beyond CRUD events, and no in-product action execution (only outbound POSTs for external systems to act on).

   • [claimed-docs] “Webhooks enable real-time notifications for memory events in your Mem0 project.”
   • [claimed-docs] “You can configure webhooks to send HTTP POST requests to your specified URLs whenever memories are created, updated, deleted, or categorized…”
   • [claimed-docs] “Configure and manage webhooks to receive real-time notifications about memory events”
   • [claimed-docs] “Webhooks enable real-time notifications for memory events in your Mem0 projec”

   proof ↗⚑ flag

   Letta~partialclaimed6/10

   Letta documents several trigger-based automation mechanisms: scheduled tasks that 'automate prompts to your agent on a recurring schedule or at a specific time' (letta-docs-69), mods that add 'event hooks' taking effect immediately (letta-docs-71), dreaming triggers configurable to fire 'after a number of steps, on context compaction, or never' (letta-docs-3/12), and Slack-connected agents that automatically respond when mentioned (letta-docs-73/83). These collectively show event- and time-based automatic action triggers, though there is no single documented general-purpose 'rules engine' where a user defines arbitrary event→action conditions in one place. Missing for 10: a unified rules/automation API or UI for arbitrary custom event conditions, and independent/hands-on confirmation that these triggers reliably fire as documented.

   • [claimed-docs] “Scheduled tasks allow you to automate prompts to your agent on a recurring schedule or at a specific time in the future.”
   • [claimed-docs] “Mods let your agent modify its own runtime — adding tools, commands, event hooks, permission policies, and provider adapters that take effec…”
   • [claimed-docs] “trigger controls when dreaming runs: after a number of steps, on context compaction, or never.”
   • [claimed-docs] “Agents connected to Slack are always-on: mention them in a channel or thread and they'll respond, using their cloud computer to do real work…”
   • [claimed-docs] “Agents connected to Slack are always-on: mention them in a channel or thread and they'll respond”
   • [claimed-docs] “trigger controls when dreaming runs: after a number of steps, on context compaction, or never”

   proof ↗⚑ flag

Forgetting

1. platform-engineerDelete a user's memories on demand — single memory, per-entity, or full erasure — to satisfy privacy requirements

   weight 2 · round to Mem0
   Mem0~partialclaimed6/10

   Mem0 documents a CLI and API that can add, search, list, update, and delete memories, and its entity-scoped memory model (user_id/agent_id/app_id) lets memories be scoped so a target audience can be identified for deletion. However, the evidence never explicitly documents a bulk 'delete all memories for a user_id' or full-erasure/right-to-be-forgotten endpoint distinct from per-memory delete, and expiration is explicitly called out as non-deletion ('Nothing is deleted'). Missing for 10: explicit bulk/per-entity erasure API or docs (e.g., delete_all by user_id), compliance-oriented erasure guarantees, and independent confirmation that full erasure actually removes underlying data/embeddings.

   • [claimed-docs] “The mem0 CLI lets you add, search, list, update, and delete memories directly from the terminal.”
   • [claimed-docs] “lets you add, search, list, update, and delete memories directly from the terminal”
   • [claimed-docs] “The mem0 CLI lets you add, search, list, update, and delete memories directly from the terminal. It works with the Mem0 Platfor”
   • [claimed-docs] “Manage memories from your terminal, for both humans and AI agents.”
   • [claimed-docs] “Scope conversations by user, agent, app, and session so memories land exactly where they belong.”
   • [claimed-docs] “Mem0's Platform API lets you separate memories for different users, agents, and apps.”
   • [claimed-docs] “Set an expiration date on a Mem0 memory and it stops surfacing in search once that date passes. Nothing is deleted.”
   • [claimed-docs] “Set an expiration date on a Mem0 memory and it stops surfacing in search once that date passes. Nothing is deleted. Works on Platform and Op…”

   proof ↗⚑ flag

   Letta—none0/10

   The evidence pack covers extensive memory creation, editing, auditing (/doctor), and consolidation (/remember, /init, dreaming) but never documents an explicit delete/erase memory command, API, or per-entity/full-wipe capability for privacy compliance. The one related command, /clear, explicitly 'resets the message buffer but keeps learned context' (letta-comm-5), meaning conversation clearing does not erase underlying memory — the opposite of the requested erasure guarantee.

   • [community] “Letta Code described by Letta's Charles as 'memory-first': agents build learned context over time via tools like /init and /remember; a /cle…”
   • [claimed-docs] “If the memory hierarchy has drifted or grown too large, run /doctor to audit placement, duplication, and system-prompt token usage.”
   • [claimed-docs] “You can also teach it explicitly with `/remember`: `> /remember always use pnpm in this repo`. The agent decides where the lesson belongs an…”

   proof ↗⚑ flag

2. developerMake memories expire or decay — via TTL, expiration dates, or recency weighting — so stale facts stop surfacing

   weight 2 · round to Mem0
   Mem0✓fullclaimed7/10

   Mem0 documents a first-class expiration_date feature that stops memories from surfacing once the date passes without deleting them, working on both Platform and Open Source (mem0-docs-11, mem0-docs-19, mem0-docs-37, mem0-docs-50, mem0-docs-58). This directly satisfies the 'expiration date' part of the story. Missing for 10: explicit TTL (duration-based) configuration syntax, recency-weighting/decay scoring in search ranking, and independent/hands-on corroboration beyond vendor docs.

   • [claimed-docs] “Set an expiration_date on a memory and Mem0 stops surfacing it once that date passes”
   • [claimed-docs] “Set an expiration date on a Mem0 memory and it stops surfacing in search once that date passes. Nothing is deleted.”
   • [claimed-docs] “Set an expiration_date on a memory and Mem0 stops surfacing it once that date passes, so you don't need a cleanup job hunting for rows to de…”
   • [claimed-docs] “Set an expiration date on a Mem0 memory and it stops surfacing in search once that date passes. Nothing is deleted. Works on Platform and Op…”
   • [claimed-docs] “Set an expiration date on a Mem0 memory and it stops surfacing in search once that date passes.”

   proof ↗⚑ flag

   Letta—none0/10

   The evidence describes Letta's memory system (dreaming/consolidation, /doctor audits, MemFS search, shared memory) but nowhere documents TTL, expiration dates, or recency-weighted decay causing stale facts to stop surfacing; /doctor flags drift/duplication but is manual, not automatic decay.

   • [claimed-docs] “trigger controls when dreaming runs: after a number of steps, on context compaction, or never.”
   • [claimed-docs] “If the memory hierarchy has drifted or grown too large, run /doctor to audit placement, duplication, and system-prompt token usage.”
   • [claimed-docs] “Dreaming uses background subagents to review recent conversations, consolidate useful lessons, and update memory without interrupting your a…”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the MemFS Search mod”

   proof ↗⚑ flag

Portability

1. platform-engineerExport memories in a machine-readable format so the memory store is portable and not a lock-in trap

   weight 2 · round to Mem0
   Mem0✓fullclaimed7/10

   Mem0 documents a dedicated Memory Export feature that creates structured exports of memories using customizable Pydantic schemas, and separately offers a self-hosted open-source deployment giving full ownership of the data and stack, both directly addressing the portability/lock-in concern. Missing for 10: no independent/hands-on verification of export fidelity or completeness, and no documented bulk import/migration tooling to move exported data between Platform and self-hosted stores.

   • [claimed-docs] “The Memory Export feature allows you to create structured exports of memories using customizable Pydantic schemas.”
   • [claimed-docs] “create structured exports of memories using customizable Pydantic schemas”
   • [claimed-docs] “Export memories in a structured format using customizable Pydantic schemas”
   • [claimed-docs] “Mem0 Open Source is the same memory engine as the Platform, running on your own infrastructure. You own the stack, the data, and every compo…”
   • [claimed-docs] “Self-host Mem0 with full control over your infrastructure and data”
   • [claimed-docs] “Mem0 Open Source is the same memory engine as the Platform, running on your own infrastructure. You own the stack”

   proof ↗⚑ flag

   Letta~partialclaimed5/10

   Letta's memory is stored as plain Markdown files in a Git-backed 'memory repository' (MemFS), and self-hosting keeps all agent state on-device with no proprietary lock-in, which implies inherent portability of memory data. However, there is no explicit documented export/import command, no described export file format spec, or CLI subcommand dedicated to exporting memories for migration — the pack only shows cloud backup/sync features, not a data-portability workflow. missing for 10: an explicit export/import command or documented export format, third-party confirmation that memory can be extracted and reloaded elsewhere, guidance on migrating memory out of Letta Cloud.

   • [claimed-docs] “Pass memory for full control over the agent’s starting memory. Each entry becomes a Markdown file in the agent’s memory repository”
   • [claimed-docs] “Shared memory gives multiple agents access to the same files and working context. Each shared memory repository is a Git repository hosted i…”
   • [claimed-docs] “Letta agents can run entirely on infrastructure you control”
   • [claimed-docs] “all agent state, including messages, memory, and provider connections, stays on-device, and no Letta account is required.”
   • [claimed-docs] “Run /login to back up your agents to the cloud and make them available through chat.letta.com, the desktop app, remote machines, and messagi…”

   proof ↗⚑ flag

Self host

1. developerRun the memory layer fully locally — embedded in-process or against local models — without any cloud dependency

   weight 1 · round to Letta
   Mem0~partialclaimed5/10

   Mem0's open-source docs clearly support self-hosting the memory engine (Docker REST server, dashboard, own infrastructure) rather than relying on the Platform SaaS, per mem0-docs-4/21/22/46/28/54. However, none of the evidence confirms an embedded in-process mode or explicit support for local embedding/LLM backends (e.g., Ollama) that would eliminate all cloud calls — the quickstart and core examples default to hosted API keys and cloud model calls. Missing for 10: explicit documentation of local/offline model backends, confirmation that vector store and embedder can run fully in-process without any external API calls, and independent verification of a no-cloud-dependency deployment.

   • [claimed-docs] “Mem0 Open Source is the same memory engine as the Platform, running on your own infrastructure. You own the stack, the data, and every compo…”
   • [claimed-docs] “Self-host Mem0 with full control over your infrastructure and data”
   • [claimed-docs] “A Docker stack with a dashboard, per-user API keys, and a request audit log.”
   • [claimed-docs] “Mem0 Open Source is the same memory engine as the Platform, running on your own infrastructure. You own the stack”
   • [claimed-docs] “Stand up the Mem0 REST server and dashboard in a few minutes, with an admin account, API keys, and a live audit log included.”
   • [claimed-docs] “Stand up the Mem0 REST server and dashboard in a few minutes, with an admin account, API keys, and a live audit log”
   • [claimed-docs] “The self-hosted bundle ships the REST API and a web dashboard together... per-user API keys and a request audit log.”

   proof ↗⚑ flag

   Letta~partialclaimed6/10

   Docs clearly describe a local-only mode where the CLI/agent state, memory, and provider connections all stay on-device with no Letta account or cloud backup required, and a self-hosted App Server that lets agents run entirely on infrastructure you control. However, the evidence never confirms running against fully local models (e.g., local LLM inference/embeddings) — 'model-agnostic' language points to swapping API-based providers (Claude, GPT, Gemini) rather than in-process/local-model operation, and other docs emphasize cloud sandboxes and server-hosted agents as the default path. Missing for 10: explicit support/documentation for local model backends (e.g., Ollama/local embeddings), and confirmation that memory/embedding search (MemFS Search) works without any external API calls.

   • [claimed-docs] “This default local mode stores agent state on your machine and does not require a Letta login.”
   • [claimed-docs] “all agent state, including messages, memory, and provider connections, stays on-device, and no Letta account is required.”
   • [claimed-docs] “Letta agents can run entirely on infrastructure you control”
   • [claimed-docs] “Self-hosted App Server: Run the Letta App Server to host local agents on a central, always-on machine and expose them to client applications…”
   • [claimed-docs] “Letta agents are **model-agnostic**. Agents can use Claude, GPT, Gemini, or other supported models. Users can change an agent's underlying m…”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the [MemFS Search mod]”

   proof ↗⚑ flag

2. platform-engineerSelf-host the memory layer from open-source code (e.g. via Docker) on infrastructure I control

   weight 3 · round to Mem0
   Mem0✓fullclaimed7/10

   Mem0 docs explicitly describe an open-source self-hosted bundle ('same memory engine as the Platform, running on your own infrastructure') delivered as a Docker stack with REST API, dashboard, per-user API keys, and audit log, giving platform engineers full infra control. Missing for 10: independent/hands-on confirmation of the Docker deployment working in practice and details on infra requirements (e.g., DB/vector store provisioning) beyond first-party docs.

   • [claimed-docs] “Mem0 Open Source is the same memory engine as the Platform, running on your own infrastructure. You own the stack, the data, and every compo…”
   • [claimed-docs] “Self-host Mem0 with full control over your infrastructure and data”
   • [claimed-docs] “A Docker stack with a dashboard, per-user API keys, and a request audit log.”
   • [claimed-docs] “The self-hosted bundle ships the REST API and a web dashboard together... per-user API keys and a request audit log.”
   • [claimed-docs] “Stand up the Mem0 REST server and dashboard in a few minutes, with an admin account, API keys, and a live audit log included.”
   • [claimed-docs] “As a self-hosted server. A Docker stack with a dashboard, per-user API keys, and a request audit log.”
   • [claimed-docs] “Mem0 Open Source is the same memory engine as the Platform, running on your own infrastructure. You own the stack”
   • [claimed-docs] “Stand up the Mem0 REST server and dashboard in a few minutes, with an admin account, API keys, and a live audit log”

   proof ↗⚑ flag

   Letta~partialprobed6/10

   Letta explicitly documents a self-hosting path: 'Letta agents can run entirely on infrastructure you control' via the self-hosted App Server, with a local mode that stores state on-device and requires no cloud account, and the agent harness is described as fully open source. However, the evidence pack contains no explicit Docker instructions, container image, or hands-on/community confirmation that self-hosting works in practice. Missing for 10: Docker/container deployment specifics, independent verification of the self-host setup succeeding.

   • [claimed-docs] “Letta agents can run entirely on infrastructure you control”
   • [claimed-docs] “Self-hosted App Server: Run the Letta App Server to host local agents on a central, always-on machine and expose them to client applications…”
   • [claimed-docs] “The Letta App Server lets you deploy the Letta agent harness as a service.”
   • [claimed-docs] “Run the Letta App Server to host local agents on a central, always-on machine and expose them to client applications”
   • [claimed-docs] “all agent state, including messages, memory, and provider connections, stays on-device, and no Letta account is required.”
   • [claimed-docs] “This default local mode stores agent state on your machine and does not require a Letta login.”
   • [probe] “PROBE llms.txt: HTTP 200 at https://docs.letta.com/llms.txt # Letta > Letta agents learn from experience and improve with use. The Letta ag…”

   proof ↗⚑ flag

Knowledge graph

1. ml-engineerStore memories as a knowledge graph of entities and relationships so multi-hop and entity-centric questions are answerable

   weight 3 · round to Mem0
   Mem0✓fullclaimed8/10

   Mem0 Platform explicitly builds a native graph linking entities, places, and concepts across memories with no external graph database required, directly supporting multi-hop and entity-centric queries like what do we know about Alice. Docs describe automatic graph construction without schema definition, replacing earlier Neo4j-based integration. missing for 10: independent or hands-on verification of graph memory multi-hop retrieval accuracy, and no benchmark showing entity-relationship correctness

   • [claimed-docs] “Mem0 Platform automatically organizes your memories into a graph... with no external graph database to provision.”
   • [claimed-docs] “Graph Memory is built in. There is no Neo4j, Memgraph, or other graph store to deploy, no connection strings to manage, and nothing to enabl…”
   • [claimed-docs] “Earlier versions connected an external graph database (Neo4j and others) and exposed a relations field. Mem0 now builds the graph itself fro…”
   • [claimed-docs] “You ask entity-centric questions like "what do we know about Alice?" and expect facts pulled from many different conversations”
   • [claimed-docs] “Mem0 Platform builds a native graph linking people, places, and concepts across your memories, with no external graph database to provision.”
   • [claimed-docs] “You previously used an external graph store and want the same cross-memory connections with zero infrastructure”
   • [claimed-docs] “Mem0 Platform automatically organizes your memories into a graph... without you defining any schema.”
   • [claimed-docs] “Mem0 Platform builds a native graph linking people, places, and concepts across your memories”

   proof ↗⚑ flag

   Letta—none0/10

   Letta's documented memory system is file/text-based (MemFS, memory blocks) with optional keyword/semantic/hybrid search (letta-docs-28, letta-docs-41), not a graph of entities and relationships; a Letta employee explicitly frames its approach as 'primarily text/files based' as an alternative to structured memory graphs (letta-comm-10). No evidence describes entity/relationship modeling or multi-hop graph traversal for memory.

   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the [MemFS Search mod]”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the MemFS Search mod”
   • [community] “Letta's Wooders responds to memory skepticism: 'the problem with ChatGPT / other RAG-based memory solutions is that it's not possible to col…”

   proof ↗⚑ flag

2. ml-engineerTrack when facts became valid or invalid (temporal reasoning) so the memory distinguishes current from outdated information

   weight 2 · round to Mem0
   Mem0~partialclaimed4/10

   Mem0 supports manual expiration_date so a memory stops surfacing after a set date, and it can update existing facts, but there is no documented capability to automatically detect when a fact becomes invalid/outdated (e.g., contradiction detection, temporal versioning, or 'valid from/until' metadata) — the expiration mechanism is a manual TTL, not temporal reasoning. Missing for 10: automatic invalidation of superseded facts, tracking validity windows for graph relations, and any evidence of reasoning about fact recency versus outdatedness.

   • [claimed-docs] “Set an expiration_date on a memory and Mem0 stops surfacing it once that date passes”
   • [claimed-docs] “Set an expiration date on a Mem0 memory and it stops surfacing in search once that date passes. Nothing is deleted.”
   • [claimed-docs] “Set an expiration_date on a memory and Mem0 stops surfacing it once that date passes, so you don't need a cleanup job hunting for rows to de…”
   • [claimed-docs] “Set an `expiration_date` on a memory and Mem0 stops surfacing it once that date passes”
   • [claimed-docs] “Set an expiration date on a Mem0 memory and it stops surfacing in search once that date passes. Nothing is deleted. Works on Platform and Op…”
   • [claimed-docs] “Set an expiration date on a Mem0 memory and it stops surfacing in search once that date passes.”
   • [claimed-docs] “Earlier versions connected an external graph database (Neo4j and others) and exposed a relations field. Mem0 now builds the graph itself fro…”

   proof ↗⚑ flag

   Letta—none0/10

   Letta's documented memory model is file/block-based (MemFS, memory blocks, dreaming/consolidation) with no evidence of tracking fact validity intervals, timestamps of when facts became true/false, or any temporal-graph reasoning distinguishing current vs outdated facts. The axis is applicable to a memory-focused product, but nothing in the evidence pack shows Letta supports temporal fact versioning.

   ⚑ flag

Schema customization

1. ml-engineerCustomize the memory schema — entity types, edge types, or ontology — to match my domain

   weight 1 · round drawn
   Mem0—none0/10

   Mem0's docs explicitly state Graph Memory is fully automatic and built 'without you defining any schema' (mem0-docs-42), with no external graph DB, connection strings, or relations field to configure (mem0-docs-23, mem0-docs-24). There is no evidence of any API, config, or ontology mechanism letting an ml-engineer define custom entity or edge types.

   • [claimed-docs] “Mem0 Platform automatically organizes your memories into a graph... without you defining any schema.”
   • [claimed-docs] “Graph Memory is built in. There is no Neo4j, Memgraph, or other graph store to deploy, no connection strings to manage, and nothing to enabl…”
   • [claimed-docs] “Earlier versions connected an external graph database (Neo4j and others) and exposed a relations field. Mem0 now builds the graph itself fro…”
   • [claimed-docs] “Mem0 Platform builds a native graph linking people, places, and concepts across your memories, with no external graph database to provision.”

   proof ↗⚑ flag

   Letta—none0/10

   Letta's documented memory model is block/file-based (Markdown memory blocks, MemFS, persona/human blocks) rather than a graph model with configurable entity types, edge types, or ontology; no evidence pack item describes schema customization of entities/relationships. missing for 10: any documentation of graph-based memory representation, entity/edge type definitions, or ontology configuration APIs.

   • [claimed-docs] “Pass memory for full control over the agent’s starting memory. Each entry becomes a Markdown file in the agent’s memory repository”
   • [claimed-docs] “`persona` and `human` are conveniences that set the agent's persona and human memory”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the [MemFS Search mod]”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the MemFS Search mod”

   proof ↗⚑ flag

Agent memory

1. ai-native userMy agent can manage its own memory mid-conversation — adding, searching, updating, and deleting memories through tools or API calls it invokes itself

   weight 3 · round drawn
   Mem0✓fullprobed8/10

   Mem0 documents an MCP server that hands agents add/search/update memory tools they can invoke themselves, a CLI supporting add/search/list/update/delete, and a flow for a coding agent to self-provision an account and start storing memories mid-session — directly matching the story of self-directed, tool-invoked memory management. Missing for 10: independent/hands-on verification that agents reliably invoke delete/update mid-conversation in practice, and explicit API-level delete examples beyond CLI mentions.

   • [claimed-docs] “The Mem0 MCP server hands your agent a set of memory tools, so it can decide for itself when to save something, look something up, or update…”
   • [claimed-docs] “The mem0 CLI lets you add, search, list, update, and delete memories directly from the terminal.”
   • [claimed-docs] “lets you add, search, list, update, and delete memories directly from the terminal”
   • [claimed-docs] “a coding agent creates its own account from the terminal and starts storing memories immediately.”
   • [claimed-docs] “Let an AI agent create its own Mem0 account and API key in four commands, with no email or dashboard needed.”
   • [probe] “official MCP server documented at https://docs.mem0.ai/platform/mem0-mcp”
   • [claimed-docs] “You send conversation turns to `add`, then call `search` before the next model request to fetch relevant context.”

   proof ↗⚑ flag

   Letta✓fullcommunity8/10

   Letta's memory system is explicitly designed for agent-driven self-editing: agents can be taught new memories via /remember, search via MemFS keyword/semantic search mods, consolidate/update via background 'dreaming', and audit/prune via /doctor — all invoked by the agent itself mid-conversation, and community evidence corroborates this as Letta's core differentiator ('memory-first', 'fully white box' memory editing). missing for 10: no direct API/tool-call schema example showing explicit add/search/update/delete operations invoked programmatically by the agent (docs describe user-facing slash commands and background dreaming rather than a fully enumerated CRUD tool API), and no independent hands-on test confirming the agent autonomously invokes these without user prompting.

   • [claimed-docs] “You can also teach it explicitly with /remember: > /remember always use pnpm in this repo”
   • [claimed-docs] “You can also teach it explicitly with `/remember`”
   • [claimed-docs] “You can also teach it explicitly with /remember”
   • [claimed-docs] “If the memory hierarchy has drifted or grown too large, run /doctor to audit placement, duplication, and system-prompt token usage.”
   • [claimed-docs] “Dreaming uses background subagents to review recent conversations, consolidate useful lessons, and update memory without interrupting your a…”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the [MemFS Search mod]”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the MemFS Search mod”
   • [community] “Letta Code described by Letta's Charles as 'memory-first': agents build learned context over time via tools like /init and /remember; a /cle…”
   • [community] “Letta's Wooders responds to memory skepticism: 'the problem with ChatGPT / other RAG-based memory solutions is that it's not possible to col…”
   • [community] “Concern raised: 'context poisoning is a real problem that these memory providers only make worse.' Letta's Charles countered that Letta's me…”

   proof ↗⚑ flag

2. ai-native userThe memory layer decides for itself what is worth remembering — extracting salient facts from raw conversation and consolidating them in the background

   weight 2 · round to Letta
   Mem0~partialcommunity7/10

   Docs show Mem0 automatically extracts individual facts from raw conversation and organizes them into a graph without user-defined schema (mem0-docs-26, mem0-docs-8, mem0-docs-38, mem0-docs-42), and the search/retrieval flow lets the system decide what's salient (mem0-docs-7, mem0-docs-43). However, evidence of true background 'self-improving' consolidation (deduping, merging over time) is thin, and one independent report notes Mem0 doesn't implicitly learn behavioral patterns beyond stored facts (mem0-comm-7), tempering the 'decides for itself' framing. Missing for 10: explicit documentation/evidence of background consolidation jobs or memory merging over time, and independent hands-on validation of extraction quality.

   • [claimed-docs] “Mem0 pulls the individual facts out of the conversation and stores each one separately”
   • [claimed-docs] “Store facts once, then retrieve them by query”
   • [claimed-docs] “Mem0 Platform automatically organizes your memories into a graph... with no external graph database to provision.”
   • [claimed-docs] “Mem0 Platform builds a native graph linking people, places, and concepts across your memories, with no external graph database to provision.”
   • [claimed-docs] “Mem0 Platform automatically organizes your memories into a graph... without you defining any schema.”
   • [claimed-docs] “You send conversation turns to `add`, then call `search` before the next model request to fetch relevant context.”
   • [community] “We looked at Mem0, Letta/MemGPT, and similar memory solutions. They all solve storing facts from conversations - key-value memory with seman…”

   proof ↗⚑ flag

   Letta✓fullcommunity8/10

   Letta's 'dreaming' feature explicitly uses background subagents to review conversations, extract salient lessons, and consolidate/update memory without interrupting active work, and /remember and /init let the agent decide where lessons belong in MemFS autonomously. Community corroboration (Charles/Wooders on HN) confirms this memory-first, self-consolidating design and contrasts it with RAG-based approaches, though skeptics questioned scaling. Missing for 10: independent hands-on benchmarking of extraction quality/accuracy and more detail on the automatic (non-explicit) salience-detection heuristics beyond trigger conditions.

   • [claimed-docs] “Dreaming uses background subagents to review recent conversations, consolidate useful lessons, and update memory without interrupting your a…”
   • [claimed-docs] “Run `/init` to bootstrap or refresh memory for the current project. The agent inspects the repository, asks about your working style when ne…”
   • [claimed-docs] “You can also teach it explicitly with `/remember`: `> /remember always use pnpm in this repo`. The agent decides where the lesson belongs an…”
   • [claimed-docs] “trigger controls when dreaming runs: after a number of steps, on context compaction, or never.”
   • [community] “Letta Code described by Letta's Charles as 'memory-first': agents build learned context over time via tools like /init and /remember; a /cle…”
   • [community] “Letta's Wooders responds to memory skepticism: 'the problem with ChatGPT / other RAG-based memory solutions is that it's not possible to col…”
   • [community] “Concern raised: 'context poisoning is a real problem that these memory providers only make worse.' Letta's Charles countered that Letta's me…”

   proof ↗⚑ flag

Benchmarks

1. ml-engineerSee published memory-quality benchmark results (e.g. LongMemEval, LoCoMo) backing the product's recall-accuracy claims

   weight 2 · round drawn
   Mem0—none0/10

   No evidence of any published benchmark results (LongMemEval, LoCoMo, or similar) or recall-accuracy metrics anywhere in the docs or community sources; the pack only covers feature descriptions and setup guides. missing for 10: any benchmark citation, LongMemEval/LoCoMo results, accuracy/recall metrics, third-party evaluation.

   ⚑ flag

   Letta—none0/10

   The evidence pack contains extensive documentation of Letta's memory architecture (MemFS, dreaming, shared memory, etc.) and community discussion of memory quality skepticism/responses, but nowhere cites any published benchmark results (LongMemEval, LoCoMo, or similar) backing recall-accuracy claims. Since memory-recall quality is a core claimed feature of Letta, this axis clearly applies, but no benchmark evidence exists in the pack.

   • [community] “'How does the memory scale (or not!) over time... if there is a memory block limit, is that an issue for self learning over time. Claude as …”
   • [community] “Skeptic comment: 'In my experience, memory is really not that helpful in most cases... Maintaining the memory is a considerable burden... Ch…”
   • [community] “Letta's Wooders responds to memory skepticism: 'the problem with ChatGPT / other RAG-based memory solutions is that it's not possible to col…”
   • [community] “Concern raised: 'context poisoning is a real problem that these memory providers only make worse.' Letta's Charles countered that Letta's me…”
   • [claimed-docs] “Dreaming uses background subagents to review recent conversations, consolidate useful lessons, and update memory without interrupting your a…”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the [MemFS Search mod]”

   proof ↗⚑ flag

Core memory

1. developerAdd memories from conversations and retrieve them later with semantic search, so context persists across sessions

   weight 3 · round to Mem0
   Mem0✓fullcommunity8/10

   Docs clearly describe the core add/search workflow (client.add, search by natural language, scoping by user/session) that persists memories across sessions, and this is corroborated by community reports of using it in production for exactly this purpose. Missing for 10: independent benchmarking of recall/semantic-search quality and long-term persistence beyond vendor docs.

   • [claimed-docs] “Store facts once, then retrieve them by query”
   • [claimed-docs] “Mem0's search operation lets agents ask natural-language questions and get back the memories that matter most.”
   • [claimed-docs] “Mem0 pulls the individual facts out of the conversation and stores each one separately”
   • [claimed-docs] “client.add(messages, user_id="user123")”
   • [claimed-docs] “You send conversation turns to `add`, then call `search` before the next model request to fetch relevant context.”
   • [claimed-docs] “Retrieve relevant memories from Mem0 using powerful semantic and filtered search capabilities.”
   • [community] “Congrats on the launch. Adding a memory layer to LLMs is a real painpoint. I've been experimenting with mem0 and it solves a real problem th…”
   • [community] “Memory is extremely useful and almost a requirement when it comes to building next level agents and Mem0 is probably the best designed/easie…”
   • [community] “We looked at Mem0, Letta/MemGPT, and similar memory solutions. They all solve storing facts from conversations - key-value memory with seman…”

   proof ↗⚑ flag

   Letta~partialcommunity6/10

   Letta clearly supports persistent memory across sessions (MemFS, /remember, stateful agents resumable across sessions/computers) and explicitly documents semantic search as an optional add-on via the 'MemFS Search mod' for keyword/semantic/hybrid search rather than a built-in default. Community commentary confirms the memory system is real and text/file-based but transparency-focused, not natively semantic-first, and some users raise unresolved concerns about memory scaling/self-improvement. missing for 10: first-party evidence that semantic search is enabled by default (not an optional mod), independent hands-on benchmarking of recall/retrieval quality, and clearer documentation of retrieval accuracy at scale.

   • [claimed-docs] “You can return to the same agent across sessions, computers, and interfaces instead of starting from scratch each time.”
   • [claimed-docs] “You can also teach it explicitly with `/remember`: `> /remember always use pnpm in this repo`. The agent decides where the lesson belongs an…”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the [MemFS Search mod]”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the MemFS Search mod”
   • [community] “Letta Code described by Letta's Charles as 'memory-first': agents build learned context over time via tools like /init and /remember; a /cle…”
   • [community] “Letta's Wooders responds to memory skepticism: 'the problem with ChatGPT / other RAG-based memory solutions is that it's not possible to col…”
   • [community] “'How does the memory scale (or not!) over time... if there is a memory block limit, is that an issue for self learning over time. Claude as …”

   proof ↗⚑ flag

2. developerRely on the memory layer to update, supersede, or merge memories when new information contradicts what was stored

   weight 2 · round to Letta
   Mem0~partialclaimed5/10

   Docs confirm an 'update' operation exists (CLI and API can update/delete memories) and webhooks fire on update events, implying the system does modify stored memories over time, but there is no explicit documentation describing automatic contradiction detection, superseding, or merging logic when new facts conflict with old ones. missing for 10: explicit description of conflict/contradiction detection, merge algorithm details, and independent hands-on evidence that Mem0 correctly resolves contradictory facts.

   • [claimed-docs] “The mem0 CLI lets you add, search, list, update, and delete memories directly from the terminal.”
   • [claimed-docs] “lets you add, search, list, update, and delete memories directly from the terminal”
   • [claimed-docs] “The mem0 CLI lets you add, search, list, update, and delete memories directly from the terminal. It works with the Mem0 Platfor”
   • [claimed-docs] “Manage memories from your terminal, for both humans and AI agents.”
   • [claimed-docs] “You can configure webhooks to send HTTP POST requests to your specified URLs whenever memories are created, updated, deleted, or categorized…”
   • [claimed-docs] “Configure and manage webhooks to receive real-time notifications about memory events”
   • [claimed-docs] “Mem0 pulls the individual facts out of the conversation and stores each one separately”

   proof ↗⚑ flag

   Letta~partialcommunity6/10

   Docs describe mechanisms that plausibly support updating/merging memory — /remember lets the agent 'decide where the lesson belongs and commit the update to MemFS' (letta-docs-66), 'dreaming' subagents 'consolidate useful lessons and update memory' (letta-docs-27), and /doctor audits for 'duplication' and drift in the memory hierarchy (letta-docs-10) — and Letta staff claim memory is transparent/controllable and addresses context-poisoning concerns (letta-comm-10, letta-comm-11). However, none of this is a concrete demonstration of contradiction detection/supersession logic, and a community skeptic raises unresolved doubts about memory scaling and self-correction (letta-comm-8, letta-comm-9) without a hands-on refutation either way. Missing for 10: explicit documentation or example of the system detecting/resolving conflicting facts, independent hands-on verification that stale memories are actually superseded rather than just appended/deduplicated.

   • [claimed-docs] “You can also teach it explicitly with `/remember`: `> /remember always use pnpm in this repo`. The agent decides where the lesson belongs an…”
   • [claimed-docs] “Dreaming uses background subagents to review recent conversations, consolidate useful lessons, and update memory without interrupting your a…”
   • [claimed-docs] “If the memory hierarchy has drifted or grown too large, run /doctor to audit placement, duplication, and system-prompt token usage.”
   • [community] “Letta's Wooders responds to memory skepticism: 'the problem with ChatGPT / other RAG-based memory solutions is that it's not possible to col…”
   • [community] “Concern raised: 'context poisoning is a real problem that these memory providers only make worse.' Letta's Charles countered that Letta's me…”
   • [community] “'How does the memory scale (or not!) over time... if there is a memory block limit, is that an issue for self learning over time. Claude as …”
   • [community] “Skeptic comment: 'In my experience, memory is really not that helpful in most cases... Maintaining the memory is a considerable burden... Ch…”

   proof ↗⚑ flag

Retrieval controls

1. developerSteer retrieval with metadata filters, keyword/hybrid search modes, or reranking instead of accepting a single fixed similarity search

   weight 2 · round to Mem0
   Mem0~partialclaimed6/10

   Mem0 docs confirm metadata-style filtering (user/agent/app/session scoping) and a dedicated reranking feature ('Advanced memory search with intelligent reranking') alongside 'semantic and filtered search capabilities', showing retrieval can be steered beyond plain similarity search. However, there is no documented keyword or hybrid (lexical+vector) search mode, and no independent benchmark validating reranking quality. Missing for 10: explicit keyword/hybrid search mode, third-party evidence of retrieval-tuning effectiveness.

   • [claimed-docs] “Reorders results using deep semantic understanding to put the most relevant memories first.”
   • [claimed-docs] “Reranking Reorders results using deep semantic understanding to put the most relevant memories first.”
   • [claimed-docs] “Advanced memory search with intelligent reranking for precise results”
   • [claimed-docs] “Retrieve relevant memories from Mem0 using powerful semantic and filtered search capabilities.”
   • [claimed-docs] “Mem0's Platform API lets you separate memories for different users, agents, and apps.”
   • [claimed-docs] “Scope conversations by user, agent, app, and session so memories land exactly where they belong.”

   proof ↗⚑ flag

   Letta~partialclaimed4/10

   Letta docs mention that installing the 'MemFS Search mod' enables keyword search and optional semantic or hybrid search, showing some retrieval-mode flexibility beyond fixed similarity search, but this requires an add-on rather than being built-in. Missing for 10: explicit metadata-filter support, reranking capability, and any evidence this mod is core/first-class rather than an optional plugin.

   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the [MemFS Search mod]”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the MemFS Search mod”

   proof ↗⚑ flag

1. ai-native userDo everything through the API that I can do in the UI

   weight 2 · round to Mem0
   Mem0~partialprobed6/10

   Mem0 is API/CLI/MCP-first: docs show a full REST API (OpenAPI spec), a CLI that can add/search/list/update/delete memories, and an MCP server exposing memory tools to agents, suggesting core operations (add, search, update, delete, scope by user/agent, webhooks, export, expiration) are all reachable via API rather than only through the dashboard. However, the dashboard is described as offering audit logs and API-key management, and there's no explicit evidence enumerating every UI-only feature and confirming full parity, so full API/UI equivalence isn't directly demonstrated. Missing for 10: an explicit comparison or docs statement confirming every dashboard feature (e.g., audit log viewing, key management, graph visualization) is also exposed via API, and independent confirmation of parity.

   • [claimed-docs] “The mem0 CLI lets you add, search, list, update, and delete memories directly from the terminal.”
   • [claimed-docs] “lets you add, search, list, update, and delete memories directly from the terminal”
   • [probe] “PROBE openapi: HTTP 200 at https://docs.mem0.ai/openapi.json — contains "openapi" key”
   • [probe] “official MCP server documented at https://docs.mem0.ai/platform/mem0-mcp”
   • [probe] “official CLI documented at https://docs.mem0.ai/platform/cli”
   • [claimed-docs] “The self-hosted bundle ships the REST API and a web dashboard together... per-user API keys and a request audit log.”
   • [claimed-docs] “Stand up the Mem0 REST server and dashboard in a few minutes, with an admin account, API keys, and a live audit log included.”

   proof ↗⚑ flag

   Letta~partialprobed5/10

   Letta's SDK/App Server exposes agent creation, memory, and OpenAI-compatible API access (letta-docs-1, letta-docs-23, letta-docs-32), suggesting an API-first architecture, but the evidence never confirms that CLI/UI-specific features like /doctor memory audits, /pin, /fork, /btw, or /agents browsing have API equivalents, and a direct probe for a public OpenAPI spec returned 404s across all candidate paths (letta-probe-2), undermining a clean 'everything via API' claim. missing for 10: explicit API endpoints/SDK methods mirroring each UI/CLI convenience command, a discoverable OpenAPI spec confirming full surface parity, and independent confirmation of parity.

   • [claimed-docs] “create an agent once, then resume it from anywhere”
   • [claimed-docs] “use the App Server’s OpenAI-compatible API with clients such as Open WebUI, or the ACP adapter with ACP clients such as Zed”
   • [claimed-docs] “The Letta App Server lets you deploy the Letta agent harness as a service.”
   • [claimed-docs] “Run the Letta App Server to host local agents on a central, always-on machine and expose them to client applications”
   • [probe] “PROBE openapi: all candidate paths 404 (https://docs.letta.com/openapi.json, https://docs.letta.com/swagger.json, https://docs.letta.com/api…”
   • [claimed-docs] “Use /fork to branch the current conversation, including its in-context history.”
   • [claimed-docs] “If the memory hierarchy has drifted or grown too large, run /doctor to audit placement, duplication, and system-prompt token usage.”
   • [claimed-docs] “Use /agents in the CLI to browse and switch agents. Pin an agent with /pin or the favorite control in the desktop app”

   proof ↗⚑ flag

2. ai-native userExport all of my data in open formats and leave

   weight 3 · round to Mem0
   Mem0~partialclaimed6/10

   Mem0 offers a Memory Export feature using customizable Pydantic schemas, a CLI to list/export memories, and self-hosted open-source deployment giving full data ownership, which together support exporting and leaving with your data. However, the export feature is schema-based/structured rather than a documented fully-open standard format, and there's no explicit bulk 'export all data and delete account' workflow or independent confirmation of export completeness. missing for 10: evidence of a full bulk export in a standard open format (e.g., JSON/CSV dump of entire account), confirmation of data portability across the graph/vector layers, and independent/hands-on verification that exports are complete and truly open.

   • [claimed-docs] “The Memory Export feature allows you to create structured exports of memories using customizable Pydantic schemas.”
   • [claimed-docs] “create structured exports of memories using customizable Pydantic schemas”
   • [claimed-docs] “Export memories in a structured format using customizable Pydantic schemas”
   • [claimed-docs] “The mem0 CLI lets you add, search, list, update, and delete memories directly from the terminal.”
   • [claimed-docs] “Manage memories from your terminal, for both humans and AI agents.”
   • [claimed-docs] “Mem0 Open Source is the same memory engine as the Platform, running on your own infrastructure. You own the stack, the data, and every compo…”
   • [claimed-docs] “Self-host Mem0 with full control over your infrastructure and data”
   • [claimed-docs] “Mem0 Open Source is the same memory engine as the Platform, running on your own infrastructure. You own the stack”

   proof ↗⚑ flag

   Letta~partialcommunity5/10

   Letta's architecture strongly favors openness: memory is stored as plain Markdown/MemFS files (letta-docs-11, letta-docs-66), shared memory is a Git repository (letta-docs-21, letta-docs-29), and self-hosting keeps 'all agent state... on-device' with no cloud account required (letta-docs-74, letta-docs-30), reinforced by community claims of a 'fully white box' text-based memory system (letta-comm-10, letta-comm-11). However, there is no explicit documented 'export my data and delete my account' feature or guarantee that cloud-hosted shared-memory git repos can be freely cloned/exported by the user. Missing for 10: an explicit data-export/account-deletion workflow, documentation on extracting cloud-hosted agent state, and independent verification that self-hosted mode fully replaces all cloud-only features.

   • [claimed-docs] “Pass memory for full control over the agent’s starting memory. Each entry becomes a Markdown file in the agent’s memory repository”
   • [claimed-docs] “Shared memory gives multiple agents access to the same files and working context. Each shared memory repository is a Git repository hosted i…”
   • [claimed-docs] “Shared memory gives multiple agents access to the same files and working context.”
   • [claimed-docs] “Letta agents can run entirely on infrastructure you control”
   • [claimed-docs] “all agent state, including messages, memory, and provider connections, stays on-device, and no Letta account is required.”
   • [community] “Letta's Wooders responds to memory skepticism: 'the problem with ChatGPT / other RAG-based memory solutions is that it's not possible to col…”
   • [community] “Concern raised: 'context poisoning is a real problem that these memory providers only make worse.' Letta's Charles countered that Letta's me…”

   proof ↗⚑ flag

3. ai-native userRead the product's source under an open license

   weight 2 · round to Letta
   Mem0~partialclaimed4/10

   Docs confirm a genuine 'Mem0 Open Source' offering that runs on your own infrastructure and gives you 'the stack, the data, and every component,' implying source availability, but no evidence pack item names the actual license (e.g., Apache/MIT) or links to a public repository for verification. missing for 10: explicit license name, link to source repository, independent confirmation of license terms.

   • [claimed-docs] “Mem0 Open Source is the same memory engine as the Platform, running on your own infrastructure. You own the stack, the data, and every compo…”
   • [claimed-docs] “Self-host Mem0 with full control over your infrastructure and data”
   • [claimed-docs] “Mem0 Open Source is the same memory engine as the Platform, running on your own infrastructure. You own the stack”

   proof ↗⚑ flag

   Letta~partialprobed6/10

   Letta's own docs state the agent harness is 'fully open source' and link to a public GitHub repo (letta-ai/letta) for the Agent SDK, giving concrete evidence of source availability. However, the evidence pack never names the actual license (e.g., Apache/MIT) or confirms the full product (App Server, CLI, memory subsystems) is under that same open license rather than just the harness. Missing for 10: explicit license identification/file, confirmation that all core components (not just the agent harness) are open-sourced, and independent corroboration of license terms.

   • [probe] “PROBE llms.txt: HTTP 200 at https://docs.letta.com/llms.txt # Letta > Letta agents learn from experience and improve with use. The Letta ag…”
   • [github] “the Letta Agent SDK for building agents into TypeScript applications”
   • [claimed-docs] “Letta agents can run entirely on infrastructure you control”

   proof ↗⚑ flag

4. ai-native userSelf-host the core product

   weight 3 · round drawn
   Mem0✓fullclaimed8/10

   Mem0 documents a distinct Open Source self-hosted bundle that runs the same memory engine as the Platform, deployable via Docker with REST API, dashboard, per-user API keys, and audit log, giving full ownership of stack and data. Missing for 10: independent/hands-on verification of self-hosting (all evidence is first-party docs) and details on feature parity limits (e.g., graph memory) between Platform and self-hosted version.

   • [claimed-docs] “Mem0 Open Source is the same memory engine as the Platform, running on your own infrastructure. You own the stack, the data, and every compo…”
   • [claimed-docs] “The self-hosted bundle ships the REST API and a web dashboard together... per-user API keys and a request audit log.”
   • [claimed-docs] “Self-host Mem0 with full control over your infrastructure and data”
   • [claimed-docs] “A Docker stack with a dashboard, per-user API keys, and a request audit log.”
   • [claimed-docs] “Stand up the Mem0 REST server and dashboard in a few minutes, with an admin account, API keys, and a live audit log included.”
   • [claimed-docs] “As a self-hosted server. A Docker stack with a dashboard, per-user API keys, and a request audit log.”
   • [claimed-docs] “Mem0 Open Source is the same memory engine as the Platform, running on your own infrastructure. You own the stack”
   • [claimed-docs] “Stand up the Mem0 REST server and dashboard in a few minutes, with an admin account, API keys, and a live audit log”

   proof ↗⚑ flag

   Letta✓fullclaimed8/10

   Letta's docs explicitly describe self-hosting the core product: running the Letta App Server on infrastructure you control, local CLI mode that stores state on-device without requiring a Letta account, and running agents entirely on infra you control (letta-docs-2, letta-docs-15, letta-docs-30, letta-docs-31, letta-docs-74). This is first-party documentation of a genuine self-host mode, not just cloud-hosted convenience. missing for 10: independent/hands-on verification that self-hosted deployment works as documented, and more detail on infra/ops requirements for self-hosting at scale.

   • [claimed-docs] “Run the Letta App Server to host local agents on a central, always-on machine and expose them to client applications through the Agent SDK”
   • [claimed-docs] “Self-hosted App Server: Run the Letta App Server to host local agents on a central, always-on machine and expose them to client applications…”
   • [claimed-docs] “Letta agents can run entirely on infrastructure you control”
   • [claimed-docs] “This default local mode stores agent state on your machine and does not require a Letta login.”
   • [claimed-docs] “all agent state, including messages, memory, and provider connections, stays on-device, and no Letta account is required.”
   • [claimed-docs] “Run the Letta App Server to host local agents on a central, always-on machine and expose them to client applications”

   proof ↗⚑ flag

Pricing

1. platform-engineerSee published pricing with a free tier and per-unit rates so I can project memory costs before committing

   weight 2 · round to Letta
   Mem0—none0/10

   No evidence in the pack mentions pricing, free tier, or per-unit rates anywhere in the docs, community, or probes; all citations concern product features (memory ops, MCP, CLI, graph memory) rather than pricing plans.

   ⚑ flag

   Letta~partialclaimed5/10

   Letta's docs confirm a published pricing page with a free BYOK tier (letta-docs-56), a capped free stateful-agent tier (letta-docs-36) and a usage-based developer plan (letta-docs-49), which addresses the free-tier and general cost-model part of the story. However, no explicit per-unit rate table (e.g., $/agent-hour, $/GB memory, $/token) is shown in the evidence, so a platform engineer cannot precisely project memory costs. Missing for 10: concrete per-unit pricing figures/rate card, and independent confirmation of actual billing granularity for memory usage.

   • [claimed-docs] “Up to 20 stateful agents”
   • [claimed-docs] “With a developer plan, you can create an unlimited number of agents but pay usage-based pricing.”
   • [claimed-docs] “You can get started with Letta for free by using models with BYOK, including coding plans from ChatGPT/Codex, Kimi, and Z.AI.”
   • [claimed-docs] “You can share agents across your team (and set permissions for access) to create custom agents for your organization”

   proof ↗⚑ flag

1. ai-native userChoose where my data is stored (region/residency)

   weight 2 · round drawn
   Mem0~partialclaimed4/10

   Mem0 does not document any explicit region/residency selection for its hosted Platform, but the Open Source self-hosted option lets users run 'on your own infrastructure' and 'own the stack, the data, and every component,' which indirectly lets a user choose where data lives by choosing their own hosting location. Missing for 10: explicit region-selection controls in the hosted Platform, documented data-residency guarantees, and any compliance/geo-location settings.

   • [claimed-docs] “Mem0 Open Source is the same memory engine as the Platform, running on your own infrastructure. You own the stack, the data, and every compo…”
   • [claimed-docs] “Self-host Mem0 with full control over your infrastructure and data”
   • [claimed-docs] “Mem0 Open Source is the same memory engine as the Platform, running on your own infrastructure. You own the stack”
   • [claimed-docs] “A Docker stack with a dashboard, per-user API keys, and a request audit log.”

   proof ↗⚑ flag

   Letta~partialclaimed4/10

   Letta offers self-hosting where 'agents can run entirely on infrastructure you control' and local mode where 'all agent state ... stays on-device' (letta-docs-30, letta-docs-74), giving users a way to control where data physically lives. However, there is no documented region/residency selection feature for the managed Letta Cloud offering itself (e.g., choosing EU vs US data centers). Missing for 10: explicit cloud region/residency picker, compliance certifications (GDPR/data-locality), and any documentation of where Letta Cloud stores data by default.

   • [claimed-docs] “Letta agents can run entirely on infrastructure you control”
   • [claimed-docs] “all agent state, including messages, memory, and provider connections, stays on-device, and no Letta account is required.”
   • [claimed-docs] “Self-hosted App Server: Run the Letta App Server to host local agents on a central, always-on machine and expose them to client applications…”
   • [claimed-docs] “This default local mode stores agent state on your machine and does not require a Letta login.”

   proof ↗⚑ flag

2. ai-native userPrevent my data from being used to train AI models

   weight 3 · round drawn
   Mem0—none0/10

   No evidence anywhere in the pack addresses opting out of AI-model-training use of data, data-training policies, or contractual/privacy commitments about training; the docs focus entirely on memory storage/retrieval features. This is a fair privacy-posture question for a data-storing SaaS product, but nothing in the evidence confirms or denies such a control exists, so it defaults to none.

   ⚑ flag

   Letta—none0/10

   No evidence pack item addresses data-training opt-out, a training-data policy, or any privacy controls preventing use of user data for model training; self-hosting is mentioned but not tied to a training-data guarantee.

   ⚑ flag

3. ai-native userControl data retention and deletion

   weight 2 · round to Mem0
   Mem0~partialclaimed6/10

   Mem0 documents CLI/API delete and update operations, expiration_date to stop surfacing memories, and self-hosted deployments giving 'full control over your infrastructure and data', plus audit logs for tracking changes — all supporting retention/deletion control. However, expiration explicitly states 'nothing is deleted' (soft suppression, not erasure), and there's no documented hard-delete/right-to-be-forgotten workflow, data export-then-purge guarantee, or retention policy enforcement (e.g., GDPR compliance statements). missing for 10: explicit hard-delete/purge guarantees, compliance-grade retention policy documentation, independent verification that deletion is permanent.

   • [claimed-docs] “The mem0 CLI lets you add, search, list, update, and delete memories directly from the terminal.”
   • [claimed-docs] “lets you add, search, list, update, and delete memories directly from the terminal”
   • [claimed-docs] “Manage memories from your terminal, for both humans and AI agents.”
   • [claimed-docs] “Set an expiration date on a Mem0 memory and it stops surfacing in search once that date passes. Nothing is deleted.”
   • [claimed-docs] “Set an expiration date on a Mem0 memory and it stops surfacing in search once that date passes. Nothing is deleted. Works on Platform and Op…”
   • [claimed-docs] “Set an expiration_date on a memory and Mem0 stops surfacing it once that date passes, so you don't need a cleanup job hunting for rows to de…”
   • [claimed-docs] “Self-host Mem0 with full control over your infrastructure and data”
   • [claimed-docs] “A Docker stack with a dashboard, per-user API keys, and a request audit log.”
   • [claimed-docs] “Stand up the Mem0 REST server and dashboard in a few minutes, with an admin account, API keys, and a live audit log included.”

   proof ↗⚑ flag

   Letta~partialclaimed5/10

   Letta gives users some retention control: local mode stores state on-device without a cloud login (letta-docs-31), self-hosting keeps 'all agent state, including messages, memory, and provider connections... on-device, and no Letta account is required' (letta-docs-74, letta-docs-30), and --ephemeral mode runs a one-shot task 'without creating, resuming, or persisting an agent, memory blocks, or MemFS' (letta-docs-14). However, there is no documented explicit 'delete agent/data' command, data-retention policy for Letta Cloud, or export/erase workflow. Missing for 10: explicit deletion/erasure command or API, documented cloud data-retention/purge policy, independent confirmation that deletion actually removes cloud-stored data.

   • [claimed-docs] “Use --ephemeral to run a one-shot task without creating, resuming, or persisting an agent, memory blocks, or MemFS”
   • [claimed-docs] “This default local mode stores agent state on your machine and does not require a Letta login.”
   • [claimed-docs] “all agent state, including messages, memory, and provider connections, stays on-device, and no Letta account is required.”
   • [claimed-docs] “Letta agents can run entirely on infrastructure you control”

   proof ↗⚑ flag

4. ai-native userOpt out of telemetry and usage tracking

   weight 2 · round drawn
   Mem0—none0/10

   No evidence in the pack discusses telemetry, usage tracking, or any opt-out/privacy configuration setting for Mem0; the docs cover memory features, self-hosting, MCP, and CLI but never mention telemetry controls.

   ⚑ flag

   Letta—none0/10

   No evidence pack item addresses telemetry, usage analytics, or an opt-out mechanism; while local self-hosted mode is documented, nothing confirms or denies data collection/telemetry settings.

   ⚑ flag

Latency

1. platform-engineerSee documented retrieval-latency targets or measured numbers (e.g. p50/p95) backing the product's speed claims

   weight 2 · round drawn
   Mem0—none0/10

   No evidence pack items mention latency numbers, p50/p95 metrics, or any documented performance/speed targets for retrieval; docs focus on features (search, graph memory, reranking) but never quantify speed.

   ⚑ flag

   Letta—none0/10

   No evidence pack item mentions retrieval latency, p50/p95, or any measured/documented performance numbers for search or memory retrieval; documentation covers features like MemFS search mods and dreaming but never quantifies speed. missing for 10: any documented latency targets, benchmark numbers, or measured p50/p95 retrieval performance data.

   ⚑ flag

Scale

1. platform-engineerIngest at scale with async or batch processing and check the status of background memory operations

   weight 2 · round drawn
   Mem0—none0/10

   The evidence pack shows single add/search operations, CLI, webhooks, and quickstart flows, but nothing about async/batch ingestion APIs or a way to poll/check status of background memory operations. This is a fair capability for a memory platform at scale, so absence of evidence yields 'none' rather than 'na'.

   • [claimed-docs] “Store facts once, then retrieve them by query”
   • [claimed-docs] “client.add(messages, user_id="user123")”
   • [claimed-docs] “You send conversation turns to `add`, then call `search` before the next model request to fetch relevant context.”
   • [claimed-docs] “The mem0 CLI lets you add, search, list, update, and delete memories directly from the terminal.”
   • [claimed-docs] “Webhooks enable real-time notifications for memory events in your Mem0 project.”

   proof ↗⚑ flag

   Letta—none0/10

   Letta's docs describe per-agent memory consolidation ('dreaming' background subagents, triggers on steps/compaction) but there is no evidence of a bulk/batch ingestion pipeline for scale data loading nor any API/CLI to check the status of background memory jobs, which is what this platform-engineer story requires.

   ⚑ flag

Agent memory

1. ai-native userConnect off-the-shelf assistants (Claude, ChatGPT, Cursor) to the same memory so every tool I use shares what it knows about me

   weight 2 · round to Mem0
   Mem0✓fullprobed8/10

   Mem0 documents an official MCP server that lets any MCP-compatible client (Claude, Cursor, etc.) connect to the same hosted memory store, plus explicit plugins for Claude Code, Cursor, and Codex, and a one-command way to point multiple clients at the hosted server, all backed by user/agent/app-scoped memory so different tools share the same persistent memory. Missing for 10: independent hands-on confirmation that ChatGPT specifically integrates via MCP/plugin (only Claude/Cursor/Codex are named) and no third-party report validating cross-tool memory sharing in practice.

   • [claimed-docs] “The Mem0 MCP server hands your agent a set of memory tools, so it can decide for itself when to save something, look something up, or update…”
   • [claimed-docs] “Plugins that let Claude Code, Cursor, Codex, and other harnesses remember your project.”
   • [claimed-docs] “Connect any AI client to Mem0 using Model Context Protocol in minutes”
   • [claimed-docs] “Point your clients at the hosted server with a single command”
   • [claimed-docs] “Scope conversations by user, agent, app, and session so memories land exactly where they belong.”
   • [probe] “official MCP server documented at https://docs.mem0.ai/platform/mem0-mcp”

   proof ↗⚑ flag

   Letta—none0/10

   Evidence shows Letta integrating with Codex, Claude Code, Hermes Agent, OpenClaw for skills (docs-57), and offering an OpenAI-compatible API for tools like Open WebUI plus an ACP adapter for Zed (docs-23), but nothing shows Letta connecting to or sharing memory with off-the-shelf Claude, ChatGPT, or Cursor specifically. Letta's MCP support is client-side (Letta consuming MCP servers, docs-61/76), and community evidence notes only a third-party 'Letta-MCP-server' built by a user, not an official integration exposing Letta memory to these named assistants.

   • [claimed-docs] “Skills are portable across the Letta app and CLI, Codex, Claude Code, Hermes Agent, OpenClaw, and other compatible agents.”
   • [claimed-docs] “use the App Server’s OpenAI-compatible API with clients such as Open WebUI, or the ACP adapter with ACP clients such as Zed”
   • [claimed-docs] “The SDK supports local stdio processes, Streamable HTTP, and legacy SSE”
   • [claimed-docs] “MCP tools are discovered from servers supplied through `mcpServers` and proxied by the SDK host to the MCP server.”
   • [community] “Charles from Letta on MCP: 'We're working on it... making Letta agents an MCP client, so that you can easily connect to MCP servers as tools…”

   proof ↗⚑ flag

Frameworks

1. developerDrop the memory layer into agent frameworks like LangChain, LangGraph, CrewAI, or the Vercel AI SDK via documented first-party integrations

   weight 2 · round to Mem0
   Mem0~partialclaimed6/10

   Docs reference setup guides covering 22 tools including LangChain, CrewAI, LlamaIndex, and the Vercel AI SDK, which directly supports the story, but the evidence pack only gives a top-level index reference rather than detailed per-framework integration docs or independent confirmation that these integrations work as advertised. Missing for 10: concrete per-framework code samples/docs excerpts (e.g. LangGraph-specific), independent/hands-on verification of the integrations, and any community confirmation of successful use with these specific frameworks.

   • [claimed-docs] “Setup guides for 22 tools, including LangChain, CrewAI, LlamaIndex, and the Vercel AI SDK.”

   proof ↗⚑ flag

   Letta—none0/10

   The evidence pack covers Letta's own Agent SDK, CLI, App Server, MCP support, and various demo apps, but contains no mention of LangChain, LangGraph, CrewAI, or Vercel AI SDK integrations anywhere in the docs, GitHub, or community sources.

   ⚑ flag

2. developerWire memory into real-time voice pipelines (e.g. LiveKit, Pipecat, ElevenLabs) with documented integrations fast enough for live conversation

   weight 1 · round drawn
   Mem0—none0/10

   The evidence pack lists integrations for LangChain, CrewAI, LlamaIndex, Vercel AI SDK, and coding-agent harnesses (Claude Code, Cursor, Codex), but never mentions LiveKit, Pipecat, ElevenLabs, or any real-time voice pipeline integration or latency guarantees for live conversation use.

   • [claimed-docs] “Setup guides for 22 tools, including LangChain, CrewAI, LlamaIndex, and the Vercel AI SDK.”
   • [claimed-docs] “Plugins that let Claude Code, Cursor, Codex, and other harnesses remember your project.”

   proof ↗⚑ flag

   Letta—none0/10

   The evidence pack contains no documentation or mention of LiveKit, Pipecat, ElevenLabs, or any real-time voice pipeline integration. The closest evidence (letta-comm-4) is a forum reply suggesting a DIY postgres-backed memory setup for a hypothetical voice use case, not a documented, low-latency SDK integration for live conversation.

   • [community] “User with a father suffering memory loss suggested Letta's framework looked interesting for building a voice-interactive LLM with memory to …”

   proof ↗⚑ flag

Sdks

1. developerBuild against official SDKs in at least Python and TypeScript with equivalent memory APIs

   weight 2 · round to Mem0
   Mem0~partialclaimed6/10

   Docs indicate both Python and JavaScript/TypeScript SDKs exist and expose the same core operations (add, search) via a common quickstart flow, and code snippets show `client.add()` usage. However, there is no dedicated documentation confirming feature parity between the two SDKs, no independent/hands-on verification of the TypeScript SDK, and most of the pack is Python-centric examples. Missing for 10: explicit TypeScript SDK reference/API docs, confirmation of full method parity across languages, and independent developer corroboration of TS SDK usage.

   • [claimed-docs] “get an API key, then save and search a memory in Python or JavaScript”
   • [claimed-docs] “client.add(messages, user_id="user123")”
   • [claimed-docs] “Set up your Mem0 Platform account, install the SDK, and store your first memory in under five minutes.”
   • [claimed-docs] “Setup guides for 22 tools, including LangChain, CrewAI, LlamaIndex, and the Vercel AI SDK.”

   proof ↗⚑ flag

   Letta~partialclaimed5/10

   The evidence extensively documents a TypeScript/JavaScript Agent SDK (client.createAgent(), sessions, streaming, MCP, browser/mobile support) but no evidence pack item confirms an official Python SDK or its API parity with the TypeScript SDK — despite Letta's backend being Python-based, docs cited here only reference the JS/TS Agent SDK and CLI. missing for 10: explicit official Python SDK documentation/package, confirmation of equivalent memory API surface (createAgent, sessions, streaming, MCP) across Python and TypeScript, and any independent corroboration of Python SDK usage.

   • [github] “the Letta Agent SDK for building agents into TypeScript applications”
   • [claimed-docs] “Create a stateful agent with `client.createAgent()`. It returns the agent's ID as a string, which you use to open sessions and manage the ag…”
   • [claimed-docs] “`resumeSession(id)` accepts either kind of ID: pass an `agent-xxx` ID to resume the agent's default conversation, or a `conv-xxx` ID to resu…”
   • [claimed-docs] “Send a message with `session.send()` and read the response with `session.stream()`. The stream yields typed events for the whole turn”
   • [claimed-docs] “Browser, Expo, and React Native applications must import the SDK from `@letta-ai/letta-agent-sdk/client`”
   • [claimed-docs] “The SDK supports local stdio processes, Streamable HTTP, and legacy SSE”
   • [claimed-docs] “MCP tools are discovered from servers supplied through `mcpServers` and proxied by the SDK host to the MCP server.”

   proof ↗⚑ flag

Context assembly

1. developerRetrieve a token-budgeted, prompt-ready context block assembled from relevant memories in one call

   weight 2 · round to Mem0
   Mem0~partialclaimed4/10

   Mem0's search operation retrieves and reranks relevant memories in a single call (mem0-docs-7, mem0-docs-10, mem0-docs-56), and quickstart flow shows add/search used to fetch context before the next model call (mem0-docs-43). However, there is no evidence of token-budget control, truncation, or an explicit prompt-ready formatted context block being assembled — search returns raw memory results, not a pre-packaged prompt string sized to a token limit. Missing for 10: token-budget parameter or context-length control, explicit prompt-template/context-block formatting output, and any independent confirmation of this packaging behavior.

   • [claimed-docs] “Mem0's search operation lets agents ask natural-language questions and get back the memories that matter most.”
   • [claimed-docs] “Reorders results using deep semantic understanding to put the most relevant memories first.”
   • [claimed-docs] “You send conversation turns to `add`, then call `search` before the next model request to fetch relevant context.”
   • [claimed-docs] “Retrieve relevant memories from Mem0 using powerful semantic and filtered search capabilities.”
   • [claimed-docs] “Advanced memory search with intelligent reranking for precise results”

   proof ↗⚑ flag

   Letta—none0/10

   Letta's docs describe memory blocks, MemFS, /doctor token audits, and search mods, but there is no evidence of a single API/CLI call that returns a token-budgeted, prompt-ready assembled context block for developer consumption outside the agent's own turn — memory in Letta is managed internally as part of the agent's system prompt, not exposed as a discrete retrieval endpoint.

   • [claimed-docs] “If the memory hierarchy has drifted or grown too large, run /doctor to audit placement, duplication, and system-prompt token usage.”
   • [claimed-docs] “Pass memory for full control over the agent’s starting memory. Each entry becomes a Markdown file in the agent’s memory repository”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the [MemFS Search mod]”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the MemFS Search mod”
   • [claimed-docs] “`persona` and `human` are conveniences that set the agent's persona and human memory”

   proof ↗⚑ flag

2. developerGet summaries of past sessions or threads so an agent can pick up where the last conversation left off

   weight 3 · round to Letta
   Mem0~partialprobed6/10

   Mem0's core design explicitly targets cross-session continuity — memories persist and are scoped by session/user/agent, and search retrieves the relevant facts before the next model call so an agent can resume context (mem0-docs-30, mem0-docs-43, mem0-probe-1). However, Mem0 stores discrete extracted facts rather than producing an actual 'summary' of a past thread/session, so the story's specific 'summary' framing is only approximated by fact retrieval, not a dedicated summarization feature. Missing for 10: an explicit session/thread summarization API or feature, and independent hands-on evidence that retrieved facts effectively reconstruct 'where we left off' in practice.

   • [claimed-docs] “Scope conversations by user, agent, app, and session so memories land exactly where they belong.”
   • [claimed-docs] “You send conversation turns to `add`, then call `search` before the next model request to fetch relevant context.”
   • [claimed-docs] “Mem0 sits between your application and your model”
   • [claimed-docs] “Mem0's search operation lets agents ask natural-language questions and get back the memories that matter most.”
   • [probe] “PROBE llms.txt: HTTP 200 at https://docs.mem0.ai/llms.txt # Mem0 > Mem0 is a memory layer for LLM agents - persistent, self-improving conte…”

   proof ↗⚑ flag

   Letta✓fullcommunity8/10

   Letta's core architecture is built around persistent, stateful agents that can be resumed across sessions/computers, with explicit APIs (resumeSession, agent IDs) and memory consolidation ('dreaming') that summarizes past conversations into durable memory so agents pick up where they left off. Community/founder commentary (letta-comm-5, letta-comm-12) corroborates the 'memory-first, no more forgetting' design intent. missing for 10: independent hands-on verification of summary/context fidelity over long horizons, and quantitative benchmarks of resume/summarization quality beyond vendor docs.

   • [claimed-docs] “You can return to the same agent across sessions, computers, and interfaces instead of starting from scratch each time.”
   • [claimed-docs] “`resumeSession(id)` accepts either kind of ID: pass an `agent-xxx` ID to resume the agent's default conversation, or a `conv-xxx` ID to resu…”
   • [claimed-docs] “Dreaming uses background subagents to review recent conversations, consolidate useful lessons, and update memory without interrupting your a…”
   • [claimed-docs] “Use /fork to branch the current conversation, including its in-context history.”
   • [claimed-docs] “`/search [query]` | Search messages across agents”
   • [claimed-docs] “Run `/init` to bootstrap or refresh memory for the current project. The agent inspects the repository, asks about your working style when ne…”
   • [claimed-docs] “You can also teach it explicitly with `/remember`: `> /remember always use pnpm in this repo`. The agent decides where the lesson belongs an…”
   • [community] “Letta Code described by Letta's Charles as 'memory-first': agents build learned context over time via tools like /init and /remember; a /cle…”
   • [community] “Letta employee describes Letta Code: 'a fundamentally different approach to coding agents with a focus on continual learning and statefulnes…”

   proof ↗⚑ flag

Ingestion

1. developerIngest documents, JSON, and business data into memory — not just chat transcripts

   weight 2 · round to Letta
   Mem0—none0/10

   All evidence describes Mem0's add/search API in terms of conversation messages (client.add(messages, user_id=...)) and fact extraction from chat turns; there is no mention of ingesting documents, PDFs, JSON payloads, or arbitrary business data as a memory source. Memory Export uses Pydantic schemas for output, not input ingestion of external structured data.

   • [claimed-docs] “Store facts once, then retrieve them by query”
   • [claimed-docs] “Mem0 pulls the individual facts out of the conversation and stores each one separately”
   • [claimed-docs] “client.add(messages, user_id="user123")”
   • [claimed-docs] “You send conversation turns to `add`, then call `search` before the next model request to fetch relevant context.”
   • [claimed-docs] “Mem0 sits between your application and your model. You send conversation turns to `add`, then call `sear”
   • [claimed-docs] “The Memory Export feature allows you to create structured exports of memories using customizable Pydantic schemas.”

   proof ↗⚑ flag

   Letta~partialclaimed5/10

   Letta's memory system (MemFS) is file/markdown-based and the SDK lets developers 'pass memory for full control' where 'each entry becomes a Markdown file' — implying arbitrary content beyond chat transcripts can seed agent memory, and /init lets an agent ingest a repository's files. However, there is no explicit documentation of ingesting structured JSON or generic 'business data' formats into memory, nor any first-party example of a document/JSON ingestion pipeline. Missing for 10: explicit JSON/structured-data ingestion support, document-upload workflows, and independent/hands-on evidence of non-chat data being loaded into agent memory.

   • [claimed-docs] “Pass memory for full control over the agent’s starting memory. Each entry becomes a Markdown file in the agent’s memory repository”
   • [claimed-docs] “Run `/init` to bootstrap or refresh memory for the current project. The agent inspects the repository, asks about your working style when ne…”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the [MemFS Search mod]”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the MemFS Search mod”
   • [claimed-docs] “`persona` and `human` are conveniences that set the agent's persona and human memory”

   proof ↗⚑ flag

2. developerStore images, PDFs, or other files as memory inputs and recall information from them later

   weight 1 · round drawn
   Mem0—none0/10

   All evidence describes Mem0 storing and retrieving text-based conversational facts (add/search operations, graph memory, expiration, etc.); nothing in the docs or community evidence mentions ingesting images, PDFs, or other file types as memory inputs.

   • [claimed-docs] “Store facts once, then retrieve them by query”
   • [claimed-docs] “Mem0 pulls the individual facts out of the conversation and stores each one separately”
   • [claimed-docs] “client.add(messages, user_id="user123")”
   • [claimed-docs] “You send conversation turns to `add`, then call `search` before the next model request to fetch relevant context.”
   • [claimed-docs] “Mem0 sits between your application and your model. You send conversation turns to `add`, then call `sear”

   proof ↗⚑ flag

   Letta—none0/10

   Letta's documented memory system (MemFS, memory blocks, /remember, /init) is explicitly text/Markdown-file based, and 'image attachments' appear only in a demo chat app's UI feature list, not as a supported memory-recall input type for PDFs or images. No evidence shows agents can ingest images or PDFs into memory and recall facts from them later.

   • [claimed-docs] “Pass memory for full control over the agent’s starting memory. Each entry becomes a Markdown file in the agent’s memory repository”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the [MemFS Search mod]”
   • [claimed-docs] “For keyword search and optional semantic or hybrid search, install the MemFS Search mod”
   • [claimed-docs] “Use this demo when you want to study a mobile interface with conversation history, streaming, tools, approvals, interruption, queued message…”

   proof ↗⚑ flag

Governance

1. platform-engineerGovern who and what can read or write memory with roles, policies, or access-control lists, and audit that access

   weight 2 · round to Mem0
   Mem0~partialclaimed4/10

   Mem0 documents per-user API keys and a request audit log in the self-hosted bundle, plus entity-scoped memory (user/agent/app/session) that could support basic access separation, but there is no evidence of role-based access control, granular permission policies, or ACLs governing who can read/write specific memories. missing for 10: RBAC/permission policies, ACL enforcement on read/write, admin console for managing roles, independent verification of audit log completeness.

   • [claimed-docs] “The self-hosted bundle ships the REST API and a web dashboard together... per-user API keys and a request audit log.”
   • [claimed-docs] “A Docker stack with a dashboard, per-user API keys, and a request audit log.”
   • [claimed-docs] “Stand up the Mem0 REST server and dashboard in a few minutes, with an admin account, API keys, and a live audit log included.”
   • [claimed-docs] “Scope conversations by user, agent, app, and session so memories land exactly where they belong.”
   • [claimed-docs] “As a self-hosted server. A Docker stack with a dashboard, per-user API keys, and a request audit log.”

   proof ↗⚑ flag

   Letta~partialclaimed3/10

   Letta's pricing docs mention you can 'share agents across your team (and set permissions for access)' for organizational use, implying some access control exists, but there is no documentation of roles, granular ACLs, or an audit log/trail for memory reads/writes. Missing for 10: documented role/policy definitions for memory access, explicit read/write ACLs on memory blocks, and any audit logging or access history feature.

   • [claimed-docs] “You can share agents across your team (and set permissions for access) to create custom agents for your organization”

   proof ↗⚑ flag

Isolation

1. developerScope memories per user, agent, or application so one tenant's memories never leak into another's retrieval

   weight 3 · round to Mem0
   Mem0✓fullclaimed7/10

   Docs explicitly describe entity-scoped memory with user_id, agent_id, app_id, and session scoping so memories 'land exactly where they belong' and are separated across users/agents/apps, matching the tenancy story directly (mem0-docs-9, mem0-docs-30, mem0-docs-35). Missing for 10: independent/hands-on verification that isolation is enforced at retrieval time (no cross-tenant leakage tested), and no detail on access-control enforcement (e.g., can a request with wrong user_id still retrieve another user's memories) beyond first-party docs.

   • [claimed-docs] “Mem0's Platform API lets you separate memories for different users, agents, and apps.”
   • [claimed-docs] “Scope conversations by user, agent, app, and session so memories land exactly where they belong.”
   • [claimed-docs] “client.add(messages, user_id="user123")”

   proof ↗⚑ flag

   Letta~partialclaimed5/10

   Letta's core model is per-agent stateful memory (each agent has its own memory blocks/files, docs-42, docs-48), and cross-agent sharing is opt-in via explicit 'shared-memory' repos (docs-8, docs-21, docs-29) rather than automatic leakage, plus team/org permission controls exist (docs-87: 'share agents across your team and set permissions for access'). However there is no documentation of explicit multi-tenant isolation guarantees (per-user/per-application namespacing, access-control enforcement details, or audit of leakage prevention) beyond these general mechanisms. Missing for 10: explicit tenant/user isolation model, documented ACL/RBAC enforcement for memory retrieval, and any independent verification that scoping prevents cross-tenant leakage.

   • [claimed-docs] “Create a stateful agent with `client.createAgent()`. It returns the agent's ID as a string, which you use to open sessions and manage the ag…”
   • [claimed-docs] “`persona` and `human` are conveniences that set the agent's persona and human memory”
   • [claimed-docs] “letta shared-memory create --name team-memory”
   • [claimed-docs] “Shared memory gives multiple agents access to the same files and working context. Each shared memory repository is a Git repository hosted i…”
   • [claimed-docs] “Shared memory gives multiple agents access to the same files and working context.”
   • [claimed-docs] “You can share agents across your team (and set permissions for access) to create custom agents for your organization”

   proof ↗⚑ flag

Sharing

1. developerShare selected memory across multiple agents or users (team or group memory) while keeping private memory private

   weight 1 · round to Letta
   Mem0~partialclaimed5/10

   Mem0's entity-scoped memory lets you scope by user_id, agent_id, app_id, and session, which can be used to segregate private memory per user while sharing memory under a common agent_id or app_id — a workable pattern for group/team memory. However, the docs never explicitly describe a 'team' or 'group' memory concept, permission model, or access-control rules distinguishing private vs shared visibility across users/agents. Missing for 10: explicit team/group memory feature, role-based access control or sharing permissions, and any documentation of enforcing privacy boundaries between scoped entities.

   • [claimed-docs] “Mem0's Platform API lets you separate memories for different users, agents, and apps.”
   • [claimed-docs] “Scope conversations by user, agent, app, and session so memories land exactly where they belong.”

   proof ↗⚑ flag

   Letta✓fullclaimed7/10

   Letta ships a dedicated shared-memory feature (`letta shared-memory create`, Git-backed shared repositories giving multiple agents common context) alongside per-agent private memory blocks, and pricing docs explicitly mention team-level agent sharing with configurable permissions. This directly matches sharing selected memory across agents/users while keeping other memory private. Missing for 10: independent/hands-on corroboration of the privacy boundary enforcement and finer-grained detail on how access permissions are scoped per user vs team.

   • [claimed-docs] “letta shared-memory create --name team-memory”
   • [claimed-docs] “Shared memory gives multiple agents access to the same files and working context. Each shared memory repository is a Git repository hosted i…”
   • [claimed-docs] “Shared memory gives multiple agents access to the same files and working context.”
   • [claimed-docs] “You can share agents across your team (and set permissions for access) to create custom agents for your organization”

   proof ↗⚑ flag