supermemory.ai

supermemory is a memory and continual-learning engine for AI agents: raw data (chats, URLs, files, raw data) enters the system, the learner-1 model extracts and "dreams on" that context, stores the result in a vector-graph database, and injects relevant memories back into the agent's context as tokens in real time. The practical payoff is that memory lives outside any single model provider, so it carries across models and harnesses. This explanation is for anyone deciding whether to build on supermemory or evaluating how its memory layer fits an agent stack.

The pipeline, step by step

The flow described on the site has four stages, shown in the site's Figure 1:

1. Ingest. Chats, URLs, files, and raw data are fed into supermemory.
2. Learn. learner-1 processes that raw context against the existing memory database, performing four operations: update, merge, infer, and forget.
3. Store. The resulting learnings go into a vector-graph database — described as dense, interconnected, and growing, with an understanding of time.
4. Inject. Prior memories are brought back to the model by injecting tokens into its context in real time, via hooks.

The key design choice is step 4: memory is delivered in-context rather than by fine-tuning or retraining the model. That is what makes it model-agnostic — the same memory can be re-injected into any model or harness.

What learner-1 actually does

learner-1 is the component that turns raw context into durable memory. The four operations are worth understanding separately:

The "understanding of time" in the database matters here: because memories carry temporal context, update and forget can distinguish what is current from what is outdated. For example, if a user tells an agent their preferred language changed last month, a time-aware store can treat the newer statement as current rather than surfacing both with equal weight.

Why memory sits outside the model

The site's stated rationale is that intelligence is no longer the binding constraint — pre-training and post-training keep pushing model capability, but they don't let a model learn and improve in real time. So learning and memory are separated from model providers and kept interoperable. In practice this means:

• Switching models or harnesses doesn't reset what the agent knows about a user, task, or tenant.
• Memory is scoped per user, task, or tenant, so multi-tenant deployments keep contexts separated.
• You are not locked to one vendor's memory feature.

How you connect to it

supermemory is available through an API, plugins, and MCP. The site also offers a setup prompt you can copy and open in an assistant (ChatGPT, Claude, Cursor, Grok are listed as compatible), which is the fastest path to a first working integration. The site reports it runs in production environments including air-gapped ones — relevant if your deployment can't reach external services.

Scale and plan differences

The site states supermemory already serves 100k+ organizations and over a trillion tokens a month. One concrete feature difference between tiers: Scale and Enterprise include advanced document extraction for PDFs, with OCR and descriptions of figures and diagrams, while Free, Pro, and Max keep standard PDF extraction. If your agents need to read scanned PDFs or diagram-heavy documents, that distinction should drive your tier choice. Current pricing is listed on the site's pricing page; check it there rather than assuming terms.

What to verify before committing

• Retrieval quality on your data. The pipeline is only as good as what learner-1 infers and what gets injected. Test with your own chats and documents to see whether the right memories surface at the right moment.
• Forgetting behavior. Confirm that superseded information is actually dropped in your use case, not just merged alongside the old version.
• Document formats. If PDFs with figures or scans are core to your workload, confirm advanced extraction is included in the tier you plan to use.
• Deployment constraints. If you operate in a restricted network, confirm the air-gapped option fits your environment before designing around the hosted API.

The fastest way to start is to copy the setup prompt from supermemory.ai and open it in an assistant you already use — ChatGPT, Claude, Cursor, or Grok are listed as supported targets. This works if you want to try memory in an existing chat or coding environment without building an integration first. If you need programmatic control or enterprise deployment, the site also offers an API, plugins, and MCP, with a sales contact for enterprise needs.

What the setup prompt does

supermemory describes itself as a memory and continual-learning engine for agents. Raw data — chats, URLs, files — enters the system; its learner-1 model extracts, merges, infers, and forgets against a vector-graph memory database; and the result is injected back into your agent's context as tokens in real time.

The setup prompt is the entry point that wires this loop into an assistant. The site presents it as a copyable block with two actions: Copy setup prompt and Open in ChatGPT / Claude / Cursor / Grok.

Step-by-step: start with the setup prompt

1. Open supermemory.ai and locate the setup prompt block near the "Build with supermemory" call to action.
2. Choose your path:
   • Click Copy setup prompt if you want to paste it into an assistant manually.
   • Click Open in ChatGPT, Claude, Cursor, or Grok to hand the prompt directly to that tool.
3. Run the prompt in your assistant. The assistant receives the setup instructions and configures the connection to supermemory's memory layer.
4. Verify it works by giving the assistant something worth remembering — for example, a preference or a project detail — then starting a new session and asking it to recall that detail. If the memory layer is connected, the context should carry over.
5. Continue in your normal workflow. From here, memory updates happen as you use the assistant: learner-1 processes new context and injects relevant prior memories via hooks into your agent's context.

If you prefer a different entry point

Common sticking points

• Model and harness portability: supermemory states that learning and memory live outside model providers, so they carry across models and harnesses. If you switch assistants later, your memory is designed to follow — but confirm the new harness supports the injection method (hooks or MCP) you rely on.
• Air-gapped environments: the site says supermemory runs everywhere, including air-gapped environments. That path is not self-serve through the setup prompt; it goes through sales.
• PDF extraction depth varies by plan: advanced document extraction — OCR plus descriptions of figures and diagrams — is listed under Scale and Enterprise. Free, Pro, and Max keep standard PDF extraction. If your use case depends on reading diagrams, check the plan comparison before committing.
• Plan details: the site links a pricing page, but the provided material does not list prices or limits for Free, Pro, Max, or Enterprise. Treat plan specifics as something to confirm on the pricing page rather than assume.

When the setup prompt is the right choice

Use it if your goal is to see memory working inside an assistant within minutes and you already have a ChatGPT, Claude, Cursor, or Grok workflow. Move to the API or MCP if you need memory embedded in a custom agent, and to sales if you need enterprise scale or an air-gapped deployment. The site reports the underlying infrastructure already serves 100k+ organizations and over a trillion tokens a month, which is a signal of production readiness rather than a substitute for testing your own use case.

Yes. supermemory is designed to sit outside the model itself: memory and learning live in supermemory's own infrastructure rather than inside a model provider, so the same memory can carry across models and harnesses. The site also states that supermemory "runs everywhere, even in air-gapped environments." The practical condition is that your agent must be able to reach supermemory and receive injected context — through the API, plugins, or MCP — so "any model" means any model your harness can wire up to that injection path, not automatic support with zero setup.

Why model choice doesn't lock your memory in

supermemory's stated position is that learning and memory should be separated from model providers and stay highly interoperable. The mechanism is in-context injection: raw data (chats, URLs, files, raw data) enters supermemory, the learner-1 model extracts and "dreams on" the context of each user, task, or tenant, updates/merges/infers/forgets against a vector-graph memory database, and the resulting memories are injected as tokens into your agent's context in real time.

Because the memory is stored and maintained outside the model, switching models or harnesses doesn't reset what the agent has learned. That is the core claim behind "any model, any harness."

What "in-context" means in practice

The model isn't retrained or fine-tuned on your data. Instead, relevant prior memories are placed into the prompt at request time. Two consequences follow:

• Portability: the same memory store can serve different models, since each just receives tokens.
• Model-agnostic behavior: the model's own weights are unchanged; improvement comes from better context, not from the model learning.

How you connect a model or harness

The site lists three access paths: API, plugins, and MCP. It also offers a setup prompt you can open in an assistant (the page names ChatGPT, Claude, Cursor, and Grok as examples) to configure the integration.

A typical flow looks like this:

1. Input: your agent's raw context — chat turns, URLs, files, or raw data.
2. Action: send it to supermemory; learner-1 processes it against the memory DB.
3. Retrieval: prior memories are injected into your agent's context via hooks before the model call.
4. Expected result: the model answers with relevant history and learnings in context, regardless of which model is behind the harness.

The exact endpoint names, SDK calls, and hook configuration aren't specified in the available page content, so check the API/plugin/MCP documentation for concrete parameters rather than assuming menu locations.

Air-gapped and self-hosted setups

The page states supermemory "runs everywhere, even in air-gapped environments." That claim matters if you can't send data to external model providers or SaaS services. However, the source material doesn't detail deployment options, licensing, or what an air-gapped install requires. Treat the air-gapped statement as a stated capability and confirm the specifics — supported deployment targets, offline model requirements, and data handling — with the team before planning around it.

Choosing based on your setup

Practical caveats

• "Any model" still needs wiring. The model must receive injected tokens through a supported path; a harness with no way to call supermemory or accept injected context won't benefit automatically.
• Scale claims are vendor-stated. The page says supermemory serves 100k+ organizations and over a trillion tokens a month; that's a company claim, not an independent benchmark.
• Pricing and plan limits are referenced via the pricing page but not detailed in the available content, so confirm tier features (especially document extraction) directly before committing.

If your goal is memory that survives model swaps and works across harnesses, supermemory's architecture is built for exactly that. If you need air-gapped deployment, verify the operational details first — the capability is stated, but the how-to isn't in the source material.

supermemory is a memory and continual learning engine for AI agents. It sits outside the model itself: raw data (chats, URLs, files, raw data) goes in, a model called learner-1 extracts and organizes it into a vector-graph memory database, and relevant memories are injected back into your agent's context in real time. You reach it through an API, plugins, or MCP, and it is designed to work with any model and any harness. It is aimed at teams that want agents to keep learning across sessions and across model providers rather than starting fresh each time.

The core mechanism

The flow described on the site has three stages:

1. Ingest — chats, URLs, files, and raw data enter supermemory.
2. Process — learner-1 "updates, merges, infers and forgets" against the memory database. The site describes the stored learnings as dense, interconnected, and growing, with an understanding of time.
3. Inject — prior memories are brought back to the model by injecting tokens into its context in real time, via hooks into your agent's context.

A concrete example: an agent handling support tickets for many tenants. Each conversation, document, and URL is ingested; learner-1 merges new facts with what it already knows about that tenant and drops stale ones; when the next ticket arrives, the relevant history is injected into the prompt so the model responds with context it was never trained on.

Why it lives outside the model

The site's argument is that model intelligence is no longer the bottleneck — pre-training and post-training keep improving models, but they don't let a model learn and improve in real time. So learning and memory should be separated from model providers and stay interoperable. That is what makes "any model, any harness" possible: switch models or tools and the memory layer carries over, and the memory stays yours.

Access and fit

Setup can start from a copyable setup prompt that opens in an assistant such as ChatGPT, Claude, Cursor, or Grok, or through "Talk to sales" for a direct conversation.

When it's a good fit — and when it isn't

Consider supermemory if you need memory that persists across sessions, tenants, or tasks; if you expect to change models or harnesses and don't want to rebuild memory each time; or if you need memory running in a restricted or air-gapped environment. If your use case is a single-session assistant with no need to recall prior interactions, a dedicated memory layer adds infrastructure you may not need.

Before committing, check the pricing page for current plan details and confirm which document-extraction tier your workload requires — the PDF capabilities differ between Free/Pro/Max and Scale/Enterprise.

The main documented difference between supermemory's plan tiers is document extraction. Free, Pro, and Max keep standard PDF extraction, while Scale and Enterprise add advanced document extraction for PDFs, including OCR and descriptions of figures and diagrams. For current plan names, limits, and prices, check the pricing page at supermemory.ai/pricing — the site does not publish those details in the material available here.

The documented split: standard vs. advanced PDF extraction

supermemory's own description of its plans draws one clear line:

So if your agents mostly work with plain-text PDFs, the lower tiers are described as sufficient. If your documents are scanned, image-heavy, or contain diagrams and figures whose content matters, the advanced extraction in Scale and Enterprise is the feature to look at.

What every tier shares

The plan split does not appear to change the core memory engine. Across the product, supermemory describes:

• A memory engine built on learner-1, which extracts and "dreams on" the context of each user, task, or tenant, stores it in a vector-graph database, and injects relevant memories back into the model's context in real time.
• Model and harness independence. Memory lives outside model providers, so it carries across models and harnesses and stays in-context and yours.
• Multiple access paths. The site lists an API, plugins, and MCP, plus a setup prompt that can be opened in assistants such as ChatGPT, Claude, Cursor, and Grok.
• Deployment flexibility, including air-gapped environments, according to the site.

The site also states the system already serves 100k+ organizations and over a trillion tokens a month. That figure describes the platform overall, not any single plan.

How to choose

1. Start with Free if you want to test the memory loop — ingesting chats, URLs, or raw data and getting memories injected into an agent's context — with standard PDF handling.
2. Move to Pro or Max when you need more room to run that same workflow; the documented feature set is the same standard extraction, so confirm current limits on the pricing page before upgrading.
3. Choose Scale or Enterprise when document quality is the bottleneck: scanned PDFs, figures, and diagrams that need OCR and descriptive extraction.
4. Contact sales for Enterprise specifics. The site offers a "Talk to sales" path, and air-gapped deployment is mentioned as available, which typically points to a sales-led conversation.

What the site does not specify

The available material does not list per-plan prices, token or storage limits, seat counts, or rate limits, and it does not state whether a free tier requires an account. Treat those as open questions and verify them on the pricing page or with sales rather than assuming any tier is unlimited or free of login requirements.

If your decision hinges only on document extraction, the rule is simple: standard PDFs → Free, Pro, or Max; OCR and figure/diagram descriptions → Scale or Enterprise. Everything else needs the current pricing page.