--- title: "Supermemory" type: "AI Tool" url: "https://aidemos.com/tools/supermemory" description: "We tested Supermemory on style, client, and project context capture. It kept scoped containers isolated, but retrieval was inconsistent and forget failed." category: "developer-tools" website: "https://supermemory.ai/" published: "2026-07-15T08:40:58.148085+00:00" updated: "2026-07-15T08:40:58.148085+00:00" --- # Supermemory Hosted agent memory with strong capture and scoping, but mixed retrieval and weak forget behavior. `API + SDK` · `Scoped by user/project` · `Memory Graph` · `Forget failure` **Website:** [Visit Supermemory](https://supermemory.ai/) > **Useful for visible agent memory, but not for trusted forgetting** > > Supermemory is a solid hosted memory layer for AI agents when you need durable context capture, scoped user/project containers, and visible debugging. It remembered style, client, and project context well, and it kept separate containers isolated, but retrieval was inconsistent, the chat-level "0 memory used" tag conflicted with the side panel, and a forget request did not reliably retire the old preference. I would use it where observability matters, but not where delete/forget correctness is mission-critical. ## Demo Recording [Video: Supermemory demo recording](https://d3epheqghktydj.cloudfront.net/supermemory-supermemory-demo-walkthrough-b1b312f5def1.mp4) *Video — Screen-recorded walkthrough used during testing.* ## Feature-by-Feature Breakdown ### Preference Memory Persistence **Verdict:** Mostly strong Stores a user's durable writing preferences and reuses them later. In this test it captured founder_001's short, direct, copy-paste-ready style, non-polished tone, proof-before-claim habit, and safer-next-step preference, then carried that context into an internal update. **Input:** ``` Session 1 under user_id founder_001: I run a small AI product/research team. When you help me, remember how I work: keep outputs short, direct, and copy-paste ready; do not make writing sound too polished or motivational; always mention what proof or artifact is needed before making a strong claim; if a task is risky or unclear, tell me the safest next step instead of guessing. ``` **Output:** > **Image** **Input:** ``` Session 2 under user_id founder_001: Today I am testing tools for an AI memory use case. I want to show users that memory is not just 'remember my favorite color.' It should help an assistant continue real work across days, remember my working style, and avoid repeating the same explanation again. Create a short internal update for my team about what I worked on today and what we should test next. ``` **Output:** > **Image** **Input:** ``` Session 3 under user_id founder_001: Now write a formal email to a potential enterprise partner asking if they are open to a product demo next week. Keep it professional. ``` **Output:** > **Image** **Bottom line:** Capture and reuse were strong, but the second-session output was slightly more polished than the user's stated preference. ### Scope Isolation by Customer and Project **Verdict:** Strong Keeps memories separated by customer/account and project container so one context does not leak into another. The benchmark kept ACME distinct from BetaCorp and separated the AI Demos memory use case from an unrelated sales-email-agent project. **Input:** ``` Session 1 under account_id client_acme_001: ACME is a client using our AI support assistant. They prefer clear next steps and do not like repeated troubleshooting. Their team already tried password reset, clearing browser cache, and switching browsers. The issue is still happening only for users with SSO enabled. ``` **Output:** > **Image** **Input:** ``` Session 5 under account_id client_beta_002: BetaCorp is a new client. They say: 'Our users cannot log in for the first time.' Draft the first support reply for BetaCorp. ``` **Output:** > **Image** **Input:** ``` Session 5 under project_id unrelated_sales_agent_project: We are building a sales email agent for a different project. Create a short kickoff note for the team. ``` **Output:** > **Image** **Bottom line:** Scope isolation was one of Supermemory's strongest qualities in this benchmark. ### Support History Retrieval **Verdict:** Weak / inconsistent Surfaces prior troubleshooting history so support replies can progress instead of repeating known steps. It was exercised on ACME's repeated SSO/login issues and a launch-testing follow-up. **Input:** ``` Session 2 under account_id client_acme_001: ACME came back today and said 'Our users still cannot log in with SSO. What should we try next?' Draft a support reply that respects what they already tried and moves to the next useful step. ``` **Output:** > **Image** **Input:** ``` Session 4 under account_id client_acme_001: ACME says 'Some users are still unable to log in during launch testing.' Draft the next support reply. ``` **Output:** > **Image** **Bottom line:** A real retrieval miss surfaced in support flow, and the later launch-testing reply still had contradictory memory signals. ### Project Memory Handoff Synthesis **Verdict:** Mixed Carries project memory across sessions and synthesizes it into a handoff note. The benchmark used the AI Demos 'Memory for AI Agents' project to test rules, direction changes, and an intern handoff. **Input:** ``` Session 1 under project_id ai_demos_memory_use_case: We are working on an AI Demos use case called Memory for AI Agents. The goal is to help users understand which memory tools are actually useful for real agent workflows. We are not promoting any tool. We are testing whether memory can help with real continuity: personal work brain, client relationship memory, and team handoff. ``` **Output:** > **Image** **Input:** ``` Session 2 under project_id ai_demos_memory_use_case: Important project rules: no observation without proof; screenshots and artifacts are primary evidence; inputs must help rank tools, not just prove that tools can store one fact; memory should be checked for retrieval, update handling, scope control, deletion or retirement, and observability; the page should stay practical and user-facing, not only technical. ``` **Output:** > **Image** **Input:** ``` Session 3 under project_id ai_demos_memory_use_case: Project direction changed slightly. The old input set was too QA-style and not relatable enough. The new direction is to use real workflows: personal work brain memory, client relationship memory, and team handoff/project continuity memory. ``` **Output:** > **Image** **Input:** ``` Session 4 under project_id ai_demos_memory_use_case: I am unavailable tomorrow. Create a handoff note for an intern who needs to continue this use case. The note should explain what the use case is about, what the current testing direction is, what rules they must follow before writing observations, and what artifacts they need to capture while testing. ``` **Output:** > **Image** **Bottom line:** Project memory was useful enough to produce a strong handoff note, but earlier turns stayed generic and the usage tag was not trustworthy. One additional flag: the handoff note's content included details (activation emails, SSO configuration checks, BetaCorp login context) that did not clearly match this project's own stored sessions — this was never confirmed as a cross-container leak, but remains an open, unverified question rather than a resolved success. ### Memory Correction and Fact Replacement **Verdict:** Unclear / weak Lets you correct old context when facts change and tries to replace stale memories with the new version. The test updated ACME from SSO to email-password login for the first launch and checked whether later replies stopped treating SSO as active. **Input:** ``` Session 3 under account_id client_acme_001: Update the client memory: ACME is no longer using SSO for this rollout. They moved to email-password login for the first launch. Do not keep treating SSO as the active issue unless they mention it again. ``` **Output:** > **Image** **Input:** ``` Session 4 under account_id client_acme_001: ACME says 'Some users are still unable to log in during launch testing.' Draft the next support reply. ``` **Output:** > **Image** **Bottom line:** The correction was acknowledged, but the UI contradiction made stale-memory replacement impossible to verify cleanly. ### Memory Deletion and Forgetting **Verdict:** Failure Accepts forget requests and aims to retire stored memories. In the test, an old preference still came back on a forced retrieval probe after a forget request. **Input:** ``` Session 1 under user_id delete_memory_001: Remember this preference: whenever you write updates for me, use a very formal corporate tone. ``` **Output:** > **Image** **Input:** ``` Session 2 under user_id delete_memory_001: Forget this preference. Do not keep using the formal corporate tone for future responses. ``` **Output:** > **Image** **Input:** ``` Forced retrieval probe under user_id delete_memory_001: What tone or writing style preference do you have on file for me? Write me a one-paragraph status update using it. ``` **Output:** > **Image** **Bottom line:** Forget acknowledgement did not equal memory retirement, and the old preference was still retrievable. ### Memory Inspection and Diagnostics **Verdict:** Good but inconsistent Supermemory's own native Memory Graph (free tier) visualizes stored documents as nodes. Separately, this report's custom test interface displayed retrieval signals — a chat-level 'X memory used' tag plus a side panel showing relevance scores — rendering data returned by Supermemory's API, not a Supermemory product screen. **Input:** ``` After the benchmark sessions, inspect the stored memories and the last-reply retrieval state. ``` **Output:** > **Image** **Input:** ``` ACME came back today and said 'Our users still cannot log in with SSO.' Draft a support reply that respects what they already tried and moves to the next useful step. ``` **Output:** > **Image** **Input:** ``` Important project rules: no observation without proof; screenshots and artifacts are primary evidence; memory should be checked for retrieval, update handling, scope control, deletion or retirement, and observability. ``` **Output:** > **Image** **Bottom line:** Mixed: the native Memory Graph is genuinely accessible on the free tier but showed no visible connections between 17 stored documents. Separately, the custom interface's retrieval tag repeatedly contradicted its own side panel, undermining trust in that signal specifically — not in Supermemory's native graph. ## Usage-based pricing with a free tier All testing in this report was done on the free tier. | Plan | Price | Notes | | --- | --- | --- | | Free (tested) | $0 | About $5/mo usage credit included; usage pauses when the limit is reached. | | Pro | $19/mo | About $20 usage included. | | Max | $100/mo | About $130 usage included. | | Scale | $399/mo | About $600 usage included; adds a self-hosted option plus SOC 2 / HIPAA. | | Enterprise | Custom | Air-gapped self-hosting available. | *Plain text usage was listed at $0.005/1K SM tokens, and rich content (PDF/audio/video) at $0.010/1K SM tokens.* ## Is It Right For You? **Use it if** - you need a hosted memory layer with API/SDK access and a visible UI for inspecting stored context - you need user, account, or project scoping to keep client and project histories separate - you want to test real multi-session memory workflows across preference, support, and project continuity **Skip it if** - you need guaranteed forget/delete retirement to be correct on the first try - you need the chat-level 'memory used' tag to be authoritative without checking the side panel - you need a graph UI that visibly renders memory relationships and connections ## Classification - **Category:** developer-tools - **Subcategory:** agent-platforms - **Type:** text ## Frequently Asked Questions **Q: Does Supermemory remember writing style across sessions?** Yes. It stored the working-style preference and reused it later. The later internal update stayed practical and direct, though it was a bit more polished than the user's stated preference. **Q: Does Supermemory keep different clients or projects isolated?** Yes. ACME and BetaCorp stayed separate, and the unrelated sales-agent project did not inherit the AI Demos project context. **Q: Can Supermemory update old memory when I correct it?** It acknowledged the correction and later avoided treating SSO as active, but the UI showed contradictory retrieval signals, so clean replacement of the old memory was not fully verifiable. **Q: Does forgetting a memory actually stop it from coming back?** No. In the forced retrieval probe, the old formal-tone preference still surfaced and influenced the reply after the forget request. **Q: What does the '0 memory used' tag mean?** The tag appeared in this report's custom test interface, rendering Supermemory's own retrieval signal — it was not reliable: it sometimes showed '0' on replies that the same interface's side panel said had retrieved relevant memories, and it also showed '0' on a reply that was clearly memory-informed. **Q: Does Supermemory generate the response itself?** No. The report says Supermemory only stores and retrieves memory; a separate LLM (OpenAI) was used to generate the response from the retrieved context. **Q: What does Supermemory cost?** The report lists a free tier with about $5/mo usage credit, then usage-based pricing of $0.005/1K SM tokens for plain text and $0.010/1K for rich content, plus Pro at $19/mo, Max at $100/mo, Scale at $399/mo, and custom Enterprise pricing. ## Similar Tools AI tools similar to Supermemory: - [Zep](https://aidemos.com/tools/zep) — Developer-first memory for AI agents that captures workflow context well, but still needs stronger stale-memory and forget control. - [Mem0](https://aidemos.com/tools/mem0) — Mem0 remembers useful agent context across sessions and makes retrieved memory visible, but stale context can linger after updates or forget requests. - [Hindsight](https://aidemos.com/tools/hindsight) — Selective, inspectable memory for real agent workflows, with strong retrieval and scope control. - [Cognee](https://aidemos.com/tools/cognee) — Inspectable graph-backed memory for AI agents, with strong provenance tracing but cautious update/delete behavior.