Free
$0forever
Wire memory into your agent and ship your first project.
NewBrain Store — browse public brains→
Persistent intelligence infrastructure
Your AI's memory shouldn't belong to your model vendor.
Every agent you run keeps its own memory, then loses it the moment you switch tools or providers. MemMesh holds that knowledge in one place your whole company can reach.
Run a frontier model for reasoning and a local one for sensitive data. Change either next quarter. What your company has learned stays where it is.
$
npx @memmesh/cli installMCP + SDKs in 5 languages · Hosted, VPC, or on-device · GDPR export & erasure
recall edges in ink · predicted next events in purple
88.7%
on LOCOMO. Mem0 scores 82.66% at the same 50-memory budget.
Model-independent
run any model, and swap it without a migration
Runs anywhere
hosted, in your VPC, or on-device
Governed by scope
sources, audit trail, GDPR export and erasure
The problem
Every agent you deploy invents its own version of reality.
Each one starts from zero and forgets when the session ends. Ask the same question in four places and you get four answers, none of which can tell you where it came from.
Then someone leaves, an app gets replaced, a model gets swapped. Whatever those agents had picked up goes with them. The context your company actually runs on ends up spread across vendors, each holding a piece of it.
The coding agent knows the repo, not why the queue was dropped in May.
The support bot knows the ticket, not what sales already promised.
The sales copilot knows the CRM fields, not the objection raised on the last call.
The analytics agent knows the warehouse, not which experiment already failed.
MemMesh gives them one memory to read from, and each still sees only what its scope allows.
The stack
What sits between your agents and your data.
Writes go down the left, reads come back up the right. Most memory products are the top four boxes. The tier below them is the part that decides something and then acts on it.
Agent runtime
Claude CodeCursorLangGraphCrewAIcustom
Any agent framework, or none at all. MemMesh is reached over MCP or an SDK.
From runtime · writes
To runtime · reads
writes
Ingestion
chatdocumentsJSONapp events
Raw signal arrives from any source the agent touches.
reads
Retrieval
hybrid searchrerankinggraph walkscope-filtered
Finds what's relevant across the graph, limited to what the calling key may see.
writes
Extraction & graph
entitiesrelationshipsdates resolvedbelief revision
Signal resolves into a temporal graph. New facts supersede stale ones instead of piling up beside them.
reads
Context assembly
token-budgetedsources attacheddeduplicated
Assembled on demand into a page sized to your token budget, not your history.
Decide & act · what memory alone can't do
Prediction
declared targetscalibratedabstains
Name what you want predicted and get a forecast from that subject's history, scored against real outcomes.
Behaviors
pattern miningdecision → outcomerecalibration
Patterns surface from activity without hand-written rules, then correct themselves as outcomes land.
Flows
memory triggersstepshuman in the loopwrite-back
A forecast or a new fact triggers real work, and whatever happens is written back.
Back to ingestion · outcomes
Governance
scopesprovenanceGDPR export & erasureaudit trailretention
Built into the data layer rather than wrapped around it. Every read and write is scope-gated, and every claim keeps a link to its source.
MemMesh engine
entitiesfacts & edgesepisodespredictions
One signed binary. Runs hosted, in your VPC, or entirely on your own machine.
One rule runs through all of it: no model decides what gets remembered. That choice is made by code you can read and test, which is why retention, sources and cost stay predictable instead of drifting with a prompt.
Model independence, measured
Same brain, different models, same score.
A brain is a ready-made memory for one domain: the facts for a subject like SEC filings, plus the know-how to use them. Point any model at it and every answer comes from that brain's data, and only that brain's data. Nothing is invented, and each answer links back to the source it came from.
| Answerer | Brain | Accuracy | Cost / q |
|---|---|---|---|
| Llama 3.1 8B (local) | — | 0.0% | $0.0007 |
| GPT-4o (frontier) | — | 0.0% | $0.0012 |
| Llama 3.1 8B (local) | 96.5% | $0.0007 | |
| GPT-4o (frontier) | 96.5% | $0.0018 |
34 SEC-finance questions graded against real 10-K filings (data.sec.gov). Same judge, dataset, and prompt across rows.
Without the brain, both models score 0%.
These are exact figures from recent filings, which no model carries on its own. So every correct answer came from the brain. That also makes the model a component you can change: an 8B running on a laptop and a frontier model score the same.
Which means you can send sensitive domains to a local model and everything else to whichever one is best this quarter. The cost difference follows: about 2.5× less per question ($0.0007 vs $0.0018), and close to free if you host the small model yourself.
We're pushing each brain toward 99%. The ceiling is set by the brain's data rather than the model, so every correction we add lifts the number without retraining anything.
It also isn't limited to one brain. The Mesh Router gives you a single endpoint across every brain a key can reach, whether you own it, bought it, or pinned it. One call pulls from all of them and tells you which brain each result came from.
Full dataset, harness & per-question verdicts are public.
The result
We beat Mem0 and Zep on LOCOMO — at 13× fewer tokens.
Every memory vendor grades LOCOMO with its own lenient judge, so we didn’t invent a friendlier one. We scored our engine under each competitor’s own judge, meaning Mem0’s partial-credit rule and Zep’s “same-topic” rule. We win overall against both, and lead on temporal, single-hop and multi-hop.
vs Mem0
88.7 vs 82.7Scored under both at a 50-memory retrieval budget
temporal90 / 86
single-hop90 / 83
multi-hop90 / 82
open-domain68 / 71
Overall88.7% vs 82.7%
13×fewer tokens per query
Most memory systems buy accuracy by flooding the context window — Mem0 stuffs up to 200 memories into every prompt. We feed the model 522 tokens, not ~7,000. Same questions, better answers, a fraction of the cost. This one needs no judge.
522MemMesh
7,000Mem0
LOCOMO, 10 conversations, answerable categories · production extraction path · gpt-4o-mini answerer, gpt-4o judge · competitor figures are their published LOCOMO numbers. Zep edges us on open-domain — their strength, shown as-is.
For developers
Wire it in this afternoon.
Everything above runs on three calls: observe, recall and search. It drops into Claude Code, Cursor, or a loop you wrote yourself. No framework to adopt, and nothing to rewrite.
agent · terminal
# Wire MemMesh into your agent in one command
npx @memmesh/cli install
# Then, from inside your agent — three primitives:
memory_observe({ text: "Customer prefers email over phone." })
memory_recall({ subjectId: "cust_42" })
# -> prior context, with provenance
memory_search({ query: "communication preferences", limit: 5 })How it works
Remember, understand, predict, act, learn.
The same loop at every scale, from one developer's brain to a whole organisation. You feed it raw text. Each recorded outcome makes the next pass better.
- STEP 01
Remember
Send raw text or a typed observation from any agent. One call, memory.observe, and the engine works out what is worth keeping. No model is asked what to remember.
- STEP 02
Understand
Those observations resolve into a graph of people, projects, decisions and the relationships between them. Every claim keeps a link back to where it came from.
- STEP 03
Predict
Name what you want predicted and the engine forecasts it from that subject's history. Each confidence score is checked against what actually happened. When the evidence is thin it abstains.
- STEP 04
Act
A forecast or a new fact can trigger a flow: call a system, run a workflow, ask a person, update a record. The answer is not where it stops.
- STEP 05
Learn
The decision and what came of it are both recorded, then fed back in. That is what lets the patterns correct themselves instead of drifting.
Most memory layers stop after step 03. A system that only remembers works the same on day 400 as it did on day one. Recording what it decided, and what came of it, is what lets it improve.
Live demo
Same question. One remembers — and predicts.
A stateless assistant starts from zero every time. Your MemMesh MeshKey recalls what matters — and tells you what’s next.
M
Your MeshKey
PRIVATEENCRYPTEDPORTABLE
13,247
Entities
327
Agents
410K
Messages
1,021
Predictions
766
PDF
47
Video
199
Images
93
Skills
What's in my memory — and what's next?
AI
AI without MemMesh
ChatGPT · Claude · any LLM
MM
AI with your MemMesh
Claude Code · Cursor · your memory
Products
Three ways to ship a brain. One engine underneath.
Packaged brains for people and teams, plus the raw engine layers for builders who want the primitives.
Product→
MeshKey
One key. Your memory, in every AI.
A private, portable memory that unlocks in every AI tool you use — Claude Code, Cursor, ChatGPT. One key carries your context, preferences, and history wherever you work.
memory.observe · memory.search · MCP
Product→
Team Brain
Shared memory your whole team can trust.
A governed org memory: a shared knowledge graph with scopes, provenance, and compliance built in — so institutional knowledge stops disappearing every time someone switches context.
scopes · provenance · compliance
Product→
Mesh Router
The gateway that wires any agent into the mesh.
The infrastructure layer: an MCP gateway plus SDKs in five languages that connect any agent, tool, or app to MemMesh — one API for observe, recall, and predict.
MCP gateway · SDKs (TS · Py · Go · .NET · Rust)
The engine
Engine→
Memory
Recall that compounds.
Cross-session persistent memory with hybrid search and a knowledge graph. The engine decides what's worth keeping, so context carries between conversations without bloating your prompts.
memory.observe · memory.search · memory.reflect
Engine→
Predictions
Foresight, not just recall.
Declare any target and the engine predicts it from a subject's history — calibrated, provenanced, and abstaining when the signal is thin. This is the layer mem0 and MemoryLake have no answer for.
lattice.predict (event · numeric · time · anomaly)
Engine→
Behaviors
From patterns to next-best-action.
The engine mines behavior into emergent patterns and closes the loop: predict, let the agent act, record the outcome, and watch the patterns recalibrate. Decisions and outcomes are first-class.
lattice.mine · learning.recordDecision / recordOutcome
Engine→
Flows
Intelligence that acts, not just answers.
An automation engine built on the memory graph. A forecast fires or a new fact lands, and a flow calls a system, runs a workflow, brings in a person, then writes the result back.
flows · triggers · runs · learning.recordOutcome
Solutions
Expert brains for the industries that lean on them.
The same grounded recall and forecasting, tuned into a domain brain for the industries that lean on it hardest.
Finance & investing
→From stateless advisors to trusted partners.
Portfolio-aware AI that remembers a client's holdings, risk profile, and prior calls — and makes calibrated buy/sell/hold decisions with a self-improving reconcile loop.
Healthcare & life sciences
→Memory that's audit-ready by construction.
Optional health estimators, provenance on every claim, and audit-ready retention with export and erasure — for teams that operate under real compliance requirements.
Commerce & retail
→Predict what each shopper wants next.
A memory of every shopper — preferences, history, intent — plus a forecast of the next purchase and the moment to make the offer. The predictive-wallet pattern, on your storefront.
Customer support & CX
→Every customer remembered across every channel.
Carry each customer's history and preferences across conversations and channels, self-correct when facts change, and surface what they're likely to need before they ask.
Use cases
One brain primitive, every team.
The same remember-predict-act loop, scoped into a brain for the way each team works.
- 01
Engineering & dev agents
Drop persistent memory into Claude Code, Cursor, or Codex via MCP in one command. A new teammate opens their editor and the agent already knows the project.
- 02
Sales & revenue
Give every rep and every AI SDR a memory of the account: past calls, objections, commitments — and a calibrated forecast of what closes next.
- 03
Marketing & growth
Remember every segment, campaign, and creative decision — and predict the offer and send-time each user is most likely to act on.
- 04
Support & success
Carry every customer's history, preferences, and prior decisions across conversations — and surface what they're likely to need next.
- 05
Research & analytics
Turn scattered findings into a durable, queryable knowledge graph with provenance on every claim — and calibrated estimates where the data is thin.
- 06
Operations & compliance
Audit-ready retention, GDPR export and erasure, and scoped memory for teams that operate under compliance requirements.
Where it fits
It sits underneath the things you already run.
MemMesh runs underneath the tools you already have rather than beside them, so the quickest way to place it is by what it isn't.
- Not a vector database
- Vectors are one index inside it. What gets stored is a resolved fact with a source and a place in the graph, not a chunk of embedded text.
- Not RAG
- RAG pulls passages to answer one question, then forgets. MemMesh keeps a running model of what is true, who it belongs to, and how it changed.
- Not infinite chat history
- Replaying the whole transcript costs more every month it grows. The engine rebuilds only the knowledge the task needs, so your token bill stops tracking your history.
- Not an agent framework
- Bring your own. LangGraph, CrewAI, Claude Code, or a loop you wrote yourself. MemMesh sits underneath it, over MCP or an SDK.
- Not a wrapper that asks a model what to remember
- Asking costs a model call every time and answers differently on Tuesday. Ours is decided in code, so you can audit the rule and predict the bill.
Keep the agent framework, the models and the tools you already use. This is the layer they all read from.
How we compare
The field is great at remembering. Two things stay open.
Mem0, Zep and MemoryLake are strong memory layers. Zep's temporal graph and MemoryLake's source tracking are genuinely good. What none of them do is forecast what happens next, or let you install and publish a specialized brain. That's the ground MemMesh is built on.
| Capability | Mem0 | Zep | MemoryLake | MemMesh |
|---|---|---|---|---|
| Cross-session memory | ||||
| Knowledge graphstructured, related recall | ||||
| Provenance on every claimtrace an answer to its source | — | |||
| Calibrated forecast of what's nextprediction, not just recall | — | — | — | |
| Specialized brains you install & publisha marketplace of domain expertise | — | — | — | |
| Flows + 681 connectorsautomate memory across your tools — like Activepieces, for memory | — | — | — | |
| Hosted or on-device, private by default | — |
yes partial— no / not advertised
Capability comparison from each product's public docs, July 2026. This is not a benchmark, and capabilities change. We credit the rest where they're strong and compare only on the axes we're built for.
Read the full comparisonsEnterprise
One intelligence layer your whole company reads from.
This isn't a shared inbox of chat logs. Every agent, team and tool works against the same memory, and each one sees only what its scope allows.
One version of reality
Your engineering agent, support bot and sales copilot stop keeping three separate pictures of the business. They read from the same one.
Knowledge that outlives its source
Why you chose that architecture two years ago. What a customer was promised. Which approach already failed. All of it outlasts the person, the app and the model that first recorded it.
Model and vendor independence
Run a frontier model for reasoning and a local one for sensitive data. Change either next quarter. Because the knowledge sits below the model, switching is a procurement decision rather than a migration.
Governed to the row
Every memory carries a scope and a source, so you can answer who knew what and when. GDPR export, right-to-erasure and audit retention are built in.
Governed by design, not as an afterthought.
On Growth and up, the compliance toolkit is on by default: export, audit and hard-delete.
SOC 2-aligned describes our controls and roadmap, not a completed certification.
- Scoped to user, team, or org
- Provenance on every claim
- GDPR export & right-to-erasure
- Audit trail, retention up to 7 years
- SSO + VPC deployment
- Data-residency options
Pricing
Start free. Scale on what you remember.
Subjects are the headline ladder, predictions are the value meter, and events are generous fair-use. Yearly is two months free.
Growth
Popular$79/mo
Scaling teams — more projects, compliance, prediction overage.
Enterprise
Custom
Unlimited scale, on-device deployment, 7-year audit retention.