Everything you need to know about Memory Stack — how it works, what it stores, and how to get started.
Memory Stack is a persistent memory layer for AI tools. It gives every AI tool you use — Claude, Cursor, ChatGPT, Gemini, and more — access to the same shared context about you: your projects, preferences, decisions, and working patterns.
Without Memory Stack, every AI conversation starts from zero. With it, your AI tools pick up where they left off — across tools, projects, and sessions.
Three steps:
Most users have their first memory recalled in under five minutes.
No download required to use the dashboard or start logging memories. Memory Stack runs in your browser at /app.
To connect AI tools (Claude Desktop, Cursor, Windsurf, etc.), you add a short JSON snippet to their config file — the dashboard generates it for you. No separate app install, no terminal commands.
A desktop companion app is available for users who want menu-bar presence and one-click tool patching, but it's entirely optional.
Notes sit in a notebook — you retrieve them manually. Memories are injected automatically into your AI context when they're relevant. You don't look them up; your AI tools get them at the moment they're needed.
Memory Stack also extracts structure from your memories: principles you've demonstrated, skills you've applied, project relationships you haven't named yet. That structure becomes part of what gets recalled.
Every recall request goes through a three-stage pipeline:
The injected context is formatted as a structured soft-prompt with citation handles, so your AI tool can reference specific memories in its response.
The Memory Graph is a visual map of how your projects relate to each other. It's computed from two signals: keyword overlap (TF-IDF filtered) and embedding centroid cosine similarity.
Edges between project nodes appear when two projects share distinctive vocabulary and semantic proximity. A language model (Haiku) runs a domain-match check on high-cosine pairs to suppress false positives — so "hotel pricing" and "SaaS pricing" won't form a spurious edge just because both use the word "pricing."
You can click any edge in the graph to drill into the specific memories driving the connection.
Principles are patterns extracted from your memories — standing rules, preferences, and working styles that your AI tools should consistently apply. They're inferred from what you do repeatedly, not what you say once.
For example: if your memories consistently show you preferring small, focused pull requests over large refactors, Memory Stack extracts that as a Principle and injects it into relevant future contexts — without you having to say it again.
Principles can be promoted from memories, edited, and versioned. They also have a Stale Shelf: if a Principle hasn't been confirmed or reinforced in a while, it surfaces for review rather than silently eroding your context.
Recall Rhythm is a heatmap of when your memories get recalled — broken down by day of week and hour. It shows which sessions are most memory-intensive and which projects drive the most context injections.
It's useful for understanding how actively your AI tools are using your memory, and for spotting patterns like "I never get recalls on Fridays" (which might mean your Friday work isn't being logged).
When you use an MCP-connected AI tool, Memory Stack can observe conversation patterns in the background — things you explain repeatedly, decisions you make, preferences you state — and queue them as memory candidates.
Passive captures land in a review queue before becoming memories. You keep, skip, or edit them. Nothing is saved automatically without your confirmation unless you've enabled auto-save high-confidence mode in Settings.
Any tool that supports the Model Context Protocol (MCP) can connect to Memory Stack. This currently includes:
.cursorrules or MCP configCLAUDE.mdClaude.ai (the web interface) supports Memory Stack via OAuth — the dashboard walks you through connecting it.
In-runtime memory is now table stakes — Claude, ChatGPT, and Gemini all have it. The key differences with Memory Stack:
Yes. Memory Stack supports BYO keys for Anthropic, OpenAI, Voyage AI, and Google. Your keys are used for embedding, extraction, and recall — they're stored encrypted and never shared.
If you don't provide keys, Memory Stack uses a shared provider pool. BYO keys give you higher rate limits and let you choose your embedding model.
Only if you explicitly connect those sources in Settings → Capture. Each connector requires OAuth authorization and shows you exactly what it will access before you approve.
Captured items land in a review queue — you decide what becomes a memory. Auto-save is opt-in and can be scoped to specific sources or confidence levels.
Context Overlaps surfaces knowledge that multiple people on your team have independently encountered and stored. When two or more team members hold memories about the same topic, those memories are clustered and surfaced as a shared context signal.
It's how Memory Stack turns individual AI context into institutional knowledge — without requiring anyone to write a wiki page.
The Commons is the shared layer of Memory Stack — patterns, principles, and context signals that emerge from across your team's memories. Individual memories stay private; Commons surfaces only what multiple people have independently confirmed.
Think of it as the difference between a person's notes and a team's collective knowledge.
Memory Stack uses quorum-based aggregation. A pattern only surfaces in the Commons if at least two (configurable) team members hold independent memories that point to it. Individual memories are never exposed directly — only the cluster that emerges from them.
Each org can configure the quorum threshold in admin settings. Engineering teams often use a higher threshold (3+) to reduce noise; smaller teams typically use 2.
Two options:
Enterprise orgs also get SAML/OIDC SSO, domain claim flow (so everyone at your domain gets memory automatically), audit logs, and configurable data retention.
Only you, by default. Memories are row-level isolated per user. Even within a team, individual memories are not visible to other team members — only Commons-level patterns that emerge from quorum aggregation.
Memory Stack staff cannot read your memories. Access requires your API key, and all reads are logged in the audit trail.
Yes. Memory Stack runs an inline PII scan at write time and flags patterns matching common identifiers (emails, phone numbers, credit card patterns, SSNs). Flagged memories are shown with a warning, and you can choose to redact the sensitive field before saving.
PII scanning is opt-in by default and can be set to block (reject high-confidence PII entirely) in org settings.
Memory Stack is on the path to SOC 2 Type I certification, targeted for Q1 2027. In the meantime, we operate with audit logging, encryption at rest and in transit, and row-level access controls.
Enterprise customers can request our current security posture documentation and penetration test results.
Yes. From the dashboard, you can delete individual memories, archive projects, or wipe your entire account. Deleted memories are soft-deleted and purged from the database after 30 days (configurable for enterprise).
You can also export everything as JSON at any time from Settings → Export.
Yes — individual use is free to get started. You get unlimited memories, all intelligence features (Memory Graph, Principles, Recall Rhythm, Context Overlaps), and connections to all MCP-compatible tools.
Teams features (Commons, Context Overlaps across org members, admin controls) are on a paid plan. Sign in to see current pricing.
No usage-based charges on recalls or memory count. Plans are flat-rate per seat. BYO AI provider keys means your embedding and extraction costs go through your own account — Memory Stack doesn't mark them up.
Memory Stack is designed to handle large corpora. The free tier has generous limits — most individual users never hit them. If you do, the dashboard shows you exactly where you are and what upgrading would unlock.
Enterprise plans have no preset limits; they're sized to your org's needs.
Read the blog for deep-dives on how specific features work, or open the dashboard and try it — most answers become obvious once you see your first recall.
Open your dashboard →