questions processed
470 answerable questions scored for coverage
Evolving memory for AI agents / 02
Memory that
evolves.
Give every agent a past it can build on. Find the evidence. Test the lesson. Change the guidance when the world moves on.
MNEMOSYNE / MEMORY COREMemory contour · 3D enhancement available
Explore the memory concept. 3D controls appear when ready.
INTERACTIVE CONCEPTExperience, held together.
One structure. Many layers. Every memory stays connected to what supports it.
Enter the memory lifecycleOpen source. Built for continuity.
One memory layer.
Your choice of agent.Local-firstModel-agnosticSDK + APIMIT licensed
Your choice of agent.Local-firstModel-agnosticSDK + APIMIT licensed
01 / Beyond the context window
Every session ends.
Experience shouldn’t.
Keep the fact and its source. The decision and its reason. The lesson and the evidence that makes it useful.
01 / CONTINUITYPick up where
The right context.
When evidence changes,
Let useful lessons
Keep your agents.
Your memory.
Pick up where
the work left off.
Persist source documents, conversations, decisions and task checkpoints. Bring constraints and next steps into the next session.
Remember & resume 02 / MNEMOSYNE RECALLThe right context.
The original within reach.
Sharper local search, optional on-device semantic recall and reranking. Fit cited context to the turn, with the original always within reach.
Find evidence 03 / MNEMOSYNE TIMELINEWhen evidence changes,
the advice moves on.
Track when a fact held and when it became known. Preserve correction history, check silent staleness and withhold obsolete guidance.
Keep current 04 / MNEMOSYNE EVIDENCE GATELet useful lessons
earn their place.
Let candidate skills accumulate controller-run trials. Require the configured evidence threshold before a procedure enters ordinary advice.
Learn from experience 05 / MNEMOSYNE MIGRATIONKeep your agents.
Connect their memory.
Use the SDK, CLI, MCP, HTTP or provider tool adapters. Migrate alongside an existing store or review a full export import.
Bring across tools 06 / CONTROLYour memory.
Open to inspection.
Trace dependencies, choose what to share and correct or forget records. Rehearse recovery with verified local backups.
Inspect & controlMeasured progress / Mnemosyne Recall
More evidence found.
More context carried forward.
A matched corpus evaluation measures what retrieval finds and what survives the context budget.
425 / 470 questions
Up from 82.13% with the earlier lexical scorer
382 / 470 questions
After the same 8,192-byte packing budget
Session-level evidence coverage, not answer accuracy. Retrieval uses the top 20 chunks; a retrieved chunk does not prove the answer-bearing sentence reached the agent. Same-day-compatible source timing permits later sources from the question’s calendar day. Read the protocol, timing policy and limits ↗
Inside the system
From raw context.
To reusable experience.
Your agent owns the conversation and the actions. Mnemosyne connects the evidence, context and feedback around every turn.
Explore the agent loopEvidence→Context→Your agent↺
01Capture the sourceOriginals stay within reach
Keep selected documents and visible conversations with source identity, ownership and revision history. The local store needs no model call.
Source capture and inspection ↗02Prepare the next turnA bounded context, with citations
Select eligible memories, summaries and original excerpts within a budget. Your host sends that context to its chosen agent; exact sources can be expanded when needed.
Adaptive context and retrieval ↗03Learn from the outcomePropose. Trial. Then reuse.
Your controller records what worked. Candidate skills accumulate passed trials under a persisted policy. We recommend two distinct tasks and two distinct verifiers; the compatibility default remains one of each. Reopening a skill cannot weaken its saved requirements.
Reflection and validation ↗04Keep experience currentChanged sources change the advice
Recheck sources and preserve when a correction became known and when it takes effect. With an evidenced correction history, earlier valid guidance stays available for the relevant time; obsolete guidance is withheld. Revalidate declared dependencies before an action.
Freshness and action checks ↗02 / A different way to switch
Start alongside.
Move at your pace.
Your agent keeps its existing memory. Mnemosyne copies the memories it retrieves and earns a greater role through paired recall checks.
Explore gradual migration
01ShadowObserve the working system
02AssistBuild confidence in parallel
03PreferUse more local memory
Existing memory Answers the queryMnemosyne Copies eligible records
Keep the familiar path.
The legacy store serves the query. Eligible returned records are copied into Mnemosyne with source identity, so adoption starts with the memories your agent actually retrieves.
Existing memory Still queriedMnemosyne Paired recall checks
Compare before relying.
Query both stores and compare their retrieval results. Policy gates control progression; uncertain or unhealthy local results keep the legacy path available.
Existing memory Checked on every queryMnemosyne Eligible local results
Grow the role. Keep the fallback.
Prefer eligible current local results while continuing to reconcile with the source. Unfamiliar records remain reachable. Return to legacy routing at any time.
Adoption guide · illustrative routing, no live account connected.
The bridge uses a read-only legacy adapter. Reviewed full imports remain available.
Mnemosyne Migration
Bring your current memory. Keep its history.
11 supported export profiles, plus a gradual bridge that copies memories as your agent uses them. Explore migration options ↗A lesson is only as good
as its evidence.
Explore a real recorded run. Watch a skill earn reuse, move between agents, and retire when its source changes.
Loading the learning-cycle recording.
Evidence, reproduction and limits
This page displays a saved run from a temporary local memory store. It does not operate your database or evaluate a language model. From the tagged source, reproduce it with npm run demo:learning.
Nothing useful
should be a black box.
Open the records. Compare the context. Follow two agent identities through a handoff and inspect exactly what changes.
Loading the recorded engine run. Open the raw evidence.
What this run verifies, and its limits
The recorded run includes source persistence, shared handoff, private-record isolation, correction cascades, context budgeting and live-store deletion. Load the inspector or read every check in the raw JSON.
From the tagged source, reproduce it with npm run demo
npm run demo:learning. All records are synthetic. This page reads a saved run; it does not connect to your memory database.
Inspectable by design
Keep the context.
Keep your control.
A memory system should make its decisions easier to inspect. Every layer keeps the source, the scope and the recovery path in view.
Explore the Mnemosyne approachEvidence, all the way down.
Source citations, dependency chains, validity windows and recorded outcomes connect a memory to what supports it.
Share with intent.
Private ownership and explicit workspace sharing. Scoped credentials, revocation and separate capture, recall and destructive permissions.
Make changes recoverable.
Preview branches and imports. Validate backups and restore to a new path. Inspect correction history or forget records from the live store.
Measure what reaches the agent.
Inspect measured retrieval and packed-context coverage. Use the matched-reader agent harness to test answer quality, stale actions and negative transfer on your own tasks.
Put experience to work
Different agents.
A common memory.
Start with one workflow. Keep the evidence and the lessons useful as the work moves forward.
01 / BUILD
02 / SUPPORT
03 / DISCOVER
04 / OPERATE
Coding agents
Resume project decisions, carry debugging lessons between sessions and retire a procedure when its source changes.
Support assistants
Keep cited preferences and prior resolution procedures, with explicit sharing and visible unknowns.
Research agents
Carry findings across sessions, return to exact source excerpts and surface evidence that needs checking.
Operations agents
Preserve incident context and runbooks. Check declared memory dependencies again before the host takes action.
Connect where you work
Your agent. Your model. Your stack.
Choose a supported interface and connect it through your host application. Find your starting point.
Build with
Mnemosyne 2.0.
Start locally, connect one agent and inspect the evidence. One package includes both the Mnemosyne Vector Engine and the Mnemosyne Local Engine. Choose the engine that fits your application.
Choose your engine ↗Available on npm / 2.0.0-rc.9 · next
Install. Run. Inspect.
Install the exact release candidate and run two offline demonstrations. The default local path needs no model API key.
Node.js 22.16 or newer
npm install mnemosy-ai@2.0.0-rc.9
npx --no-install mnemosy demo
npx --no-install mnemosy learning-demoVersion 2 is available on next; latest stays on 1.0.1. Test your workload before production.
How is this different from a vector database?
Mnemosyne connects retrieval to the rest of an agent’s memory lifecycle: original evidence, task state, two time axes, correction history, source checks and tested skills. Mnemosyne Recall uses scoped relevance scoring by default. Optional semantic search and reranking extend it while keeping the same ownership and evidence checks.
Can I keep my current memory system?
Yes. Connect a read-only legacy adapter to the gradual bridge, then start in shadow mode. It copies eligible retrieved memories and compares recall before increasing local reliance. It continues checking the original store, including in prefer mode. Full migration is also available through supported export profiles.
Which agents and models can I connect?
Use TypeScript, the Python HTTP client, CLI, MCP or authenticated HTTP. Provider adapters expose scoped memory operations and virtual files through supported tool-calling interfaces. Your host supplies the model, account and integration; these interfaces do not import consumer account memories automatically.
Can memory intelligence run on my device?
Yes. Mnemosyne On-Device Intelligence provides optional CPU embeddings and reranking. Provision the supported runtime and model weights explicitly, then use the cached models offline. The default local store and lexical recall work without models or an API key; observation and reflection still need a provider you configure. Explore on-device setup.
What does it cost to run?
Mnemosyne is MIT licensed, with no software license fee. The local store and default lexical retrieval need no API key or model call. Optional embedding, observation and reflection providers have their own costs, as does your infrastructure. See the local and provider paths.
Where does my data live?
The Mnemosyne Local Engine stores data in a database file you control. Optional embedding, extraction or reflection providers receive only the inputs your application supplies. The database and backups are not encrypted by Mnemosyne; protect their filesystem access and choose providers deliberately.
What is ready to try today?
The v2.0.0-rc.9 npm candidate includes both engines, the recall upgrade, temporal context, optional CPU inference, persisted skill gates and gradual migration. Install the exact version or choose the next channel. The published recall measurements remain the frozen rc.8 study; this packaging release does not represent a new benchmark run. The Python client remains available from source. The demos are saved integration runs; the corpus results measure evidence coverage. Generated-answer quality, hosted synchronization and enterprise identity remain outside the verified release. Read the release boundaries.
Independent by origin. Ambitious by design.
Build the next
chapter with us.
Mnemosyne is built by Aristotle Intelligence Inc., a Delaware company. Development has been fully self-funded to date.
We welcome conversations with investors and partners who share our ambition for persistent, useful agent memory.
Fully self-funded Delaware, USAInvestors & partners
Explore what comes next.
Discuss the company, the technology and opportunities to work together.
Advanced memory systemsBring us your use case.
Need custom memory architecture, specialized integrations or more advanced capabilities for your agents? Let’s discuss what you need.
Direct contact 28naem@gmail.com
Make the next turn count
Build on what
your agents know.
Open source. Your infrastructure. Room to build.