ZenBrain
OfficialZenBrain's MCP server gives an AI agent a persistent, neuroscience-inspired long-term memory across sessions through five tools.
Store memories (
zenbrain_store): write content into long-term memory with automatic routing — procedures (steps/procedural wording), episodes (emotional weight > 0.5), pinned core blocks (confidence > 0.9), or semantic facts; optional overrides for type, steps, tools, source, context, outcome, confidence and emotional weight.Recall memories (
zenbrain_recall): search episodic, semantic, procedural and core layers (optionally working memory) by plain-language query, ranked by score, with filters forlimit,minScore,minConfidence; returns ids, layers, scores, confidence, emotional weight and duplicate links.Forget memories (
zenbrain_forget): permanently delete a memory by id and layer, cascading to consolidation-linked memories and working-memory copies; reports everything else removed.Consolidate (
zenbrain_consolidate): run a consolidation pass that promotes emotionally weighted recent episodes into semantic facts and decays stale working-memory slots.Inspect state (
zenbrain_health): read-only counts of working-memory slots, short-term interactions, episodes, facts (and how many are due for review), procedures and core blocks.
Stores ZenBrain's memory in PostgreSQL, with pgvector support for embeddings, enabling self-hosted persistent memory across sessions.
Stores ZenBrain's long-term memory in a local SQLite database, enabling self-hosted persistent memory across sessions.
Provides Vercel AI SDK middleware (@zensation/ai-sdk) that adds ZenBrain's long-term memory capabilities to AI applications and agents built with the Vercel AI SDK.
npm install @zensation/algorithms # the library, Node 22 or newer
claude mcp add --scope user zenbrain -e ZENBRAIN_DB=~/.zenbrain/memory.db -- npx -y @zensation/mcp # memory for Claude CodeVersions at a glance (checked 4 November 2026)
Repository release | v0.6.2, 15 November 2026. |
Packages |
|
Research records | Software: Zenodo 10.5281/zenodo.24247664 (v0.6.2; all versions under 10.5281/zenodo.22260018) · Paper: version 9, Zenodo 10.5281/zenodo.23832288 and arXiv:2604.23878v4 |
Three ways in
In the browser: the playground above runs this published code; nothing to install.
Across Claude Code sessions: the Claude Code plugin starts
@zensation/mcp0.3.1. A note stored in one session comes back in the next when the question shares words with it, as the topsemanticresult with a score above 0; recall is lexical until you add an embedding provider. Checked on 4 November 2026 at the protocol level: two server processes, one memory file, Node 22.23.3.Re-running the numbers: first what was measured, then the reproduction packages with the raw material and the scripts that check it.
arXiv preprint (cs.AI): arxiv.org/abs/2604.23878
Open-access archive (Zenodo / CERN): doi.org/10.5281/zenodo.19353663
Current version: version 9 (31 October 2026), Zenodo 10.5281/zenodo.23832288; arXiv:2604.23878v4
ORCID: 0009-0001-1793-012X
License: CC BY 4.0 (paper) · Apache-2.0 (code)
@misc{bering2026zenbrain,
title = {ZenBrain: A Neuroscience-Inspired 7-Layer Memory Architecture for Autonomous AI Systems},
author = {Bering, Alexander},
year = {2026},
eprint = {2604.23878},
archivePrefix = {arXiv},
primaryClass = {cs.AI},
doi = {10.5281/zenodo.19353663},
url = {https://arxiv.org/abs/2604.23878}
}Feedback, replications, and counter-results are explicitly welcome — please open an issue or reach out via research@zensation.ai.
Your AI forgets everything after every conversation. ZenBrain gives it a memory that lasts across sessions, split into layers the way human memory is, and ships the mechanisms memory research describes (spaced repetition, emotional tagging, Hebbian strengthening, forgetting curves, sleep replay) as tested functions. Which of them run on their own and which you call yourself is in one table.
Architecture vs. this package. ZenBrain's architecture is seven memory layers, a MemoryCoordinator and nine foundational algorithms, plus six Predictive Memory Architecture (PMA) components (paper, version 9). The six PMA components are proprietary: they run in our own private production system and are not in these packages, which contain the hooks they plug into. This open-source package ships the algorithm library: 10 core algorithms + 10 advanced research modules (20 modules), zero-dependency.
Benchmark: LongMemEval-500
What was measured. On LongMemEval-500 (500 questions), the measured ZenBrain arm is a Python port of a scoring class from our test harness, not the seven-layer system and not an import of these packages. Input tokens are counted in the answer step only; building the memory is not counted. Source: paper version 9, Zenodo 10.5281/zenodo.23832288 (31 October 2026) and arXiv:2604.23878v4.
In that setup, three of nine head-to-head comparisons hold against Letta, Mem0 and A-Mem — all three against A-Mem; the remaining six, against Letta and Mem0, show no significant difference. Three competitors x three LLM judges, Bonferroni-corrected (alpha = 0.05/18) and version-matched. That arm reaches 91.3% of the binary-judge accuracy of a full-context comparison arm (whose answer model reads the whole history) with 1/109.7 of its input tokens in the answer step (47.7% vs. 52.2%).
Agreement between LLM judges is not the same as independent confirmation: the paper counts three repetitions of one model as one rater. Our separate package voteworth measures how many independent votes a judge or voter panel is actually worth; in its bundled screen, ten LLM voters from four model families count as about 1.5.
Works out of the box without an embedding provider — lexical ranking, nothing extra
to install. nomic-embed-text can be added as the embedding provider; it was the embedder of the
measured run. The figures above were not measured with this package: per the correction notice,
the measured arm is a Python port of a test-harness class, not an import of the packages.
The paper prints where ZenBrain loses as well: on LoCoMo, substring-based aggregate F1 favours lexical retrieval (BM25) by metric design, and we do not contest that. The advantage is most pronounced in the judge-graded comparisons and on cross-session reasoning.
The mechanism comparison further down re-runs from this repository in under a minute —
bash scripts/compare-mechanisms.sh, no API keys; it needs git, Node and network access to clone the three
compared repositories at the pinned commits. It prints a positive
and a negative control before the result, so the instrument can be checked before its output
is trusted. The mechanism ablation behind paper Tables 7–9 also runs from here: cd backend && npm run experiments, and CI compares every point estimate with the published ones. The method and the effect
sizes behind the LongMemEval numbers above are in the paper; this repository ships no runner for those.
The archived packages below run the significance tests and effect sizes in full, and the mechanism ablation
behind paper Tables 7–9.
Method, effect sizes and ablations: arXiv:2604.23878
Open-access archive: 10.5281/zenodo.19353663
Related MCP server: memory-mcp
Reproduction packages
The raw material behind the numbers above is deposited on Zenodo, open access and citable. Both links are concept DOIs and resolve to the latest version, the same convention this README uses for the paper archive; each description was measured against the version named after it.
Mechanism ablation, paper Tables 7–9 — 10.5281/zenodo.22162063 (described here: v1.0.0). Four experiment suites (95 tests), the reference JSON the paper's tables were generated from, and
verify-against-reference.mjs, which diffs a fresh run against that reference and exits non-zero on drift.npm install && npm run experiments; the run itself needs no API keys and no network, and finishes in under a minute on a laptop. Two of the paper's other ablation tables need data this package does not carry: Table 11 the LoCoMo corpus, Table 13 a different pipeline. The package says so itself.Measurement package, LongMemEval-500 and the real-pipeline flag ablation — 10.5281/zenodo.22161977 (described here: v1). Per-(system, judge, seed) judged outputs, the flag manifests as recorded at run time, a
SHA256SUMS.txtcovering every file in the package, and the analysis scripts. Three of those scripts are stdlib-only and self-checking — the full-context comparison behind the 91.3% figure, the judge-agreement figures, and the real-pipeline flag-ablation table: each prints every re-derived value next to the reference it has to match, and exits non-zero on mismatch. The significance tests behind the nine head-to-head comparisons against Letta, Mem0 and A-Mem sit in a separate script that needs numpy and scipy; it recomputes all eighteen pairwise tests and rewrites the deposited significance JSON byte-identically, so what catches a mismatch there is the checksum, not an exit code.
Both packages name what they do not cover. Replications and counter-results are welcome: research@zensation.ai.
How ZenBrain differs from Mem0, Letta and Zep
ZenBrain's architecture takes its mechanisms from human memory research: nine foundational algorithms, which are in this library, and six Predictive Memory Architecture components, which are not public. In the paper's comparison table, none of the eight compared systems has more than two of the nine features. The table below records which of five of these mechanisms appear in the public source of three widely used memory systems, at pinned versions, on a fixed date.
Mechanism | ZenBrain | Mem0 | Letta | Zep |
FSRS-style spaced repetition | yes | — | — | — |
Hebbian learning | yes | — | — | — |
Ebbinghaus forgetting curves | yes | — | — | — |
Sleep consolidation | yes | — | — | — |
Emotional tagging | yes | — | — | — |
Zero runtime dependencies | yes | — | — | n/a |
How this was measured, 27 August 2026. Full-text search over the public source of mem0ai/mem0 at tag ts-v3.1.7 (npm mem0ai 3.1.7, PyPI mem0ai 2.0.19), letta-ai/letta-code at tag v0.31.2 (npm @letta-ai/letta-code 0.31.2) and getzep/zep at commit 7de18df, its last before that date, lockfiles excluded. getzep/zep holds examples and integrations for the hosted Zep Cloud, whose own source is not public: a dash in the Zep column covers that repository only, and there is no library to count dependencies of. A dash means the term does not occur in that snapshot — not that the system cannot do something comparable under another name. One case we know of: Letta Code revises memory in the background and calls it "dreaming" (sleep-time compute), which the term search for sleep consolidation does not match. In ZenBrain the mechanisms in this table are library functions; which of them the coordinator runs is in this table. Dependency counts are declared direct dependencies: @zensation/core resolves to two packages, both our own; mem0ai declares four, @letta-ai/letta-code eighteen. Re-run the whole check — the five mechanism rows and the dependency counts, at these pins — with scripts/compare-mechanisms.sh (--latest runs it against today's default branches instead); it prints its own positive and negative controls so you can see the instrument works before you trust the result.
Human memory does not work like a key-value store. The brain keeps specialised systems for different kinds of memory, forgets actively, modulates by emotion and retrieves by context. ZenBrain brings those mechanisms to AI agents, as a memory system with seven layers and as a library of the algorithms behind them.
Advanced algorithms (since v0.3.0, May 2026)
On top of the 10 core algorithms above, @zensation/algorithms ships 10 advanced algorithms grounded in recent neuroscience and ML research. Each is exposed as its own sub-path (@zensation/algorithms/<name>) and remains zero-dependency:
fsrs-vmPFC— Prediction-Error coupled FSRShebbian-two-factor— Two-Factor synaptic consolidationsleep-simulation-selection— RL-based replay selectionspectral-health— Fiedler-value KG health monitorib-budget— Information-Bottleneck retention budgetdopamine-routing·hopfield-stm·personalized-pagerank·surprise-gradient-memory·temporal-multi-route
See CHANGELOG.md for details.
What runs on its own, and what you call yourself
@zensation/core is a memory system: the MemoryCoordinator stores, recalls, consolidates and
forgets. @zensation/algorithms is a library of twenty modules of tested functions, and the
coordinator calls only a few of them. Several mechanisms named in this README live in the library
alone; you wire them into your own system where you want them.
Mechanism | The coordinator ( | The library ( |
Layers | Seven layer classes. | — |
Routing |
| — |
Emotional tagging | At |
|
Spaced repetition (FSRS-style) | Every fact gets an FSRS-style schedule. | FSRS-style scheduling, prediction-error-coupled FSRS |
Forgetting | Nothing in long-term memory decays or is deleted on its own. | Ebbinghaus retention, personal decay profiles |
Consolidation |
| Sleep replay ( |
Hebbian learning | Not used: core keeps no knowledge graph. | Classic and two-factor Hebbian |
Bayesian confidence | Not used. |
|
Context-dependent retrieval | Not used. The |
|
The six Predictive Memory Architecture components of the paper are not in the packages; the packages contain the hooks they plug into (see Architecture vs. this package above).
Quick Start
Requires Node.js 22 or newer (since
0.4.0). On Node 20 or older, npm silently installs the last compatible release (@zensation/algorithms@0.3.4,@zensation/core@0.2.2) instead of the current one — which looks like a broken package but is a platform mismatch. See CHANGELOG.
npm install @zensation/algorithmsimport {
initFromDecayClass,
getRetrievability,
updateAfterRecall,
tagEmotion,
computeEmotionalWeight,
computeHebbianStrengthening,
propagateForRelation,
} from '@zensation/algorithms';
// 1. Schedule a memory with the FSRS-style scheduler
const memory = initFromDecayClass('normal_decay');
// 2. A week later, check recall probability (Ebbinghaus curve)
const aWeekLater = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000);
const retention = getRetrievability(memory, aWeekLater);
console.log(`Recall probability: ${(retention * 100).toFixed(1)}%`);
// ~36.8% — retrievability has decayed over the week
// 3. User recalled it anyway — update scheduling
const updated = updateAfterRecall(memory, 4, retention, aWeekLater);
// stability 7 -> 8.19: recalling at low retrievability gives a bigger boost
// 4. Tag emotional significance
const emotion = tagEmotion('I am absolutely thrilled — I got the promotion!');
const weight = computeEmotionalWeight(emotion);
console.log(`Decay multiplier: ${weight.decayMultiplier}x`);
// 2.7x — emotional memories decay nearly 3x slower
// 5. Strengthen knowledge connections (Hebbian)
const stronger = computeHebbianStrengthening(1.0);
// 1.09 — "neurons that fire together wire together"
// 6. Propagate confidence through your knowledge graph
const confidence = propagateForRelation(0.5, 0.8, 1.0, 'supports');
// 0.9 — supporting evidence increases confidenceWant the advanced algorithms?
import {
computeKGPredictionError,
computeAdaptiveFSRSInterval,
} from '@zensation/algorithms/fsrs-vmPFC';
// Couple FSRS-style scheduling with the prediction-error signal from your
// knowledge graph: when the embedding has shifted a lot since the last
// review (high cosine distance), shrink the next interval; otherwise push
// it out. Both arrays must have the same length.
const lastEmbedding = [0.1, 0.2, 0.3, 0.4];
const currentEmbedding = [0.5, 0.4, 0.1, 0.2];
const pe = computeKGPredictionError(lastEmbedding, currentEmbedding);
const nextInterval = computeAdaptiveFSRSInterval(14, pe);Each advanced algorithm has its own sub-path (@zensation/algorithms/spectral-health, @zensation/algorithms/ib-budget, …). All zero dependencies.
Runnable examples
Seven examples live in examples/; five run on the workspace packages alone, two need a
third-party SDK installed (the examples README says which):
Example | Shows |
Working Memory + Short-Term Memory for conversation context — no SDK needed | |
An Anthropic Claude assistant that remembers across conversations | |
ZenBrain as the memory backend of a LangChain agent | |
Multiple agents sharing Working Memory, with Hebbian strengthening | |
A memory-aware system prompt for the Vercel AI SDK | |
ZenBrain as long-term memory for a LlamaIndex.TS agent — LlamaIndex keeps the short-term window, ZenBrain decides what outlives it | |
ZenBrain behind a Mastra agent: a Processor records each turn, and the instructions are rebuilt from what is currently recallable |
npx tsx examples/basic-chatbot.tsThe integration examples additionally need their respective SDK installed; examples/README.md lists which. Open good first issues are the best way in if you want to contribute.
The Science Behind It
7-Layer Memory Architecture
Layer 7: Cross-Context Memory ← Entity links across domains (experimental)
Layer 6: Core Memory ← Pinned facts (Letta-style)
Layer 5: Procedural Memory ← "How to do X" (skills & workflows)
Layer 4: Long-Term Semantic ← Facts with FSRS-style scheduling
Layer 3: Episodic Memory ← Concrete experiences & events
Layer 2: Short-Term / Session ← Current conversation context
Layer 1: Working Memory ← Active task focus (7±2 items)Each layer holds a different kind of memory and is stored and searched in its own way.
FSRS-style Spaced Repetition
FSRS (Free Spaced Repetition Scheduler) is the open scheduler Anki offers as an alternative to its legacy SM-2 algorithm; its authors report that, in simulations, users need 20–30% fewer reviews than with SM-2 for the same retention (ABC of FSRS). It uses the desirable difficulty principle: reviewing when retention is low gives a bigger stability boost. @zensation/algorithms follows FSRS in the form of its updates; its constants are not fitted and its forgetting curve is exponential (details). In @zensation/core every fact gets an FSRS-style schedule; your application reports each review with recordReview(), and the scheduler sets the next one.
Emotional Memory
The amygdala modulates memory consolidation — emotional events are remembered more vividly (flashbulb memory). ZenBrain's emotional tagger assigns arousal, valence, and significance scores using about 170 weighted keywords in four lists (English & German). In the library, emotional weight stretches decay half-lives up to 3x (computeEmotionalWeight); the coordinator uses the weight to route emotional content to episodic memory and to choose what consolidation promotes.
Hebbian Learning
"Neurons that fire together wire together" (Hebb, 1949). Knowledge graph edges that are frequently co-activated grow stronger. Unused edges decay and eventually get pruned. The result: a self-organizing knowledge structure that reflects actual usage patterns, with homeostatic normalization to prevent runaway growth. These are library functions; @zensation/core keeps no knowledge graph, so you apply them to a graph of your own.
Ebbinghaus Forgetting Curves
Ebbinghaus (1885) showed that memory decays exponentially: R = e^(-t/S). The library implements personalized decay profiles that adapt to individual learning patterns, with SM-2-compatible call signatures for existing spaced repetition code (the stability update itself takes the form of FSRS's). In the coordinator, only working memory decays.
Context-Dependent Retrieval
Tulving's Encoding Specificity Principle (1973): memories are recalled better when the retrieval context matches the encoding context. The library captures temporal context (time of day, day of week) and task type, and calculateContextSimilarity turns a match between a stored and the current context into a boost factor of up to 1.3 — a design constant, not a measured effect. The coordinator stores no encoding context; its includeContext option never had an effect and was withdrawn in 0.5.0.
Bayesian Confidence Propagation
Knowledge isn't isolated — facts support or contradict each other. The library propagates confidence through a knowledge graph you keep, one edge per call, with Bayesian-style (noisy-OR) updates: supporting evidence increases confidence, contradictions decrease it, with damping for numerical stability.
Sleep Consolidation
During sleep, the hippocampus replays recent experiences, strengthening important memories and pruning weak connections (Stickgold & Walker, 2013). ZenBrain simulates this process: selectForReplay() prioritizes emotional and recently-accessed memories, simulateReplay() boosts their stability by 50%, and pruneWeakConnections() removes weak Hebbian edges — a threshold rule inspired by the Synaptic Homeostasis Hypothesis (Tononi & Cirelli, 2006). The coordinator's consolidate() does not run this replay; it turns emotionally weighted episodes among the 100 most recent into facts, once each.
import { selectForReplay, simulateReplay } from '@zensation/algorithms/sleep-consolidation';
// Select memories for overnight consolidation
const toReplay = selectForReplay(allMemories);
// Simulate sleep replay — stability ↑, weak edges pruned
const result = simulateReplay(toReplay);
console.log(`Replayed ${result.summary.totalReplayed} memories, avg stability +${result.summary.avgStabilityIncrease.toFixed(1)} days`);Memory Coordinator
The MemoryCoordinator puts the layers behind one API — inspired by Global Workspace Theory (Baars, 1988):
import { MemoryCoordinator } from '@zensation/core';
const memory = new MemoryCoordinator({ storage: adapter, embedding: embedder });
// Auto-routes to the right layer (semantic, episodic, procedural, or core)
await memory.store('User prefers TypeScript', { type: 'auto' });
// Cross-layer search with ranked, deduplicated results
const results = await memory.recall('programming preferences');
// Forget a memory by the id and layer of a recall result (a fact consolidated from it goes too)
await memory.forget(results[0].id, results[0].layer);
// Consolidate: emotionally weighted episodes among the 100 most recent become facts, once each;
// working memory decays
await memory.consolidate();
// Facts whose FSRS-style review is due; report each review with recordReview()
const dueItems = await memory.getReviewQueue();Packages
Package | Description | Status |
20 algorithm modules — 10 core (FSRS-style scheduling, Hebbian, Ebbinghaus, emotional, Bayesian, sleep consolidation, intervals, visualization) + 10 advanced (vmPFC-FSRS, two-factor Hebbian, IB budget, Hopfield STM, …) | :white_check_mark: Published | |
Memory layers, coordinator, adapter interfaces | :white_check_mark: Published | |
PostgreSQL + pgvector storage adapter | :white_check_mark: Published | |
SQLite storage adapter (zero-config) | :white_check_mark: Published | |
MCP server — gives any MCP client (Claude Desktop, Claude Code, Cursor) five tools over five of the seven layers. Carries the protocol SDK, so the core stays dependency-free | :white_check_mark: Published | |
Vercel AI SDK middleware — recall before the model call, store after it. Works with any provider, zero runtime dependencies | :white_check_mark: Published |
Tree-Shakeable Imports
Every algorithm is available as a subpath export:
// Import everything
import { tagEmotion, updateAfterRecall } from '@zensation/algorithms';Or just what you need (better tree-shaking):
import { updateAfterRecall } from '@zensation/algorithms/fsrs';
import { tagEmotion } from '@zensation/algorithms/emotional';
import { computeHebbianStrengthening } from '@zensation/algorithms/hebbian';
import { propagateForRelation } from '@zensation/algorithms/bayesian';
import { selectForReplay } from '@zensation/algorithms/sleep-consolidation';
import { getRetrievabilityWithCI } from '@zensation/algorithms/intervals';
import { generateRetentionCurve } from '@zensation/algorithms/visualization';Use Cases
AI Chatbots with Long-Term Memory
import { initFromDecayClass, getRetrievability, type FSRSState } from '@zensation/algorithms/fsrs';
import { tagEmotion, computeEmotionalWeight } from '@zensation/algorithms/emotional';
// When your AI learns a fact about the user:
function rememberFact(fact: string): FSRSState {
const weight = computeEmotionalWeight(tagEmotion(fact));
// Emotional facts start with more stability: the multiplier runs from 1 to 3,
// and initFromDecayClass applies up to 2x of it to the base stability.
return initFromDecayClass('normal_decay', weight.decayMultiplier);
}
// Before each conversation, check what needs reinforcement:
function getFactsDueForReview(facts: FSRSState[]) {
return facts.filter(f => getRetrievability(f) < 0.7);
}Knowledge Graph with Self-Organizing Edges
import { computeHebbianStrengthening, computeHebbianDecay } from '@zensation/algorithms/hebbian';
import { propagateForRelation } from '@zensation/algorithms/bayesian';
// When two concepts are mentioned together:
function coActivate(edge: { weight: number }) {
edge.weight = computeHebbianStrengthening(edge.weight);
}
// Periodic maintenance — decay unused edges:
function decayEdges(edges: { weight: number; lastUsed: Date }[]) {
for (const edge of edges) {
edge.weight = computeHebbianDecay(edge.weight);
// 0 means the edge fell below MIN_WEIGHT (0.1): prune it
}
}RAG with Confidence Scoring
import { propagateForRelation, isSignificantChange } from '@zensation/algorithms/bayesian';
type Fact = { confidence: number };
type Relation = { source: Fact; target: Fact; weight: number; type: string };
// After retrieval, propagate confidence through related facts:
function updateConfidenceGraph(relations: Relation[]) {
for (const rel of relations) {
const newConf = propagateForRelation(
rel.target.confidence,
rel.source.confidence,
rel.weight,
rel.type // a key of PROPAGATION_FACTORS: 'supports', 'contradicts', 'causes', 'requires', 'part_of', …
);
if (isSignificantChange(newConf, rel.target.confidence)) {
rel.target.confidence = newConf;
}
}
}Extracted From Production
These aren't toy implementations — ZenBrain's algorithms are extracted from ZenAI, our first product, which ran in production in our own operation. Everything claimed here is verifiable in this repository:
948 tests as of v0.6.2 (539 algorithms · 164 core · 88 adapter-sqlite · 65 adapter-postgres, 12 of them against a real PostgreSQL · 64 mcp · 28 ai-sdk), all passing
Zero runtime dependencies in
@zensation/algorithmsand@zensation/core(core depends only on algorithms) — pure TypeScript, dual ESM + CJS, tree-shakeable subpath exportsReproducible — building from this source produces the same 153-file
@zensation/algorithms@0.6.1tarball published on npm7-layer memory architecture grounded in published neuroscience
Contributing
We welcome contributions! See CONTRIBUTING.md for guidelines. Issues and pull requests are answered; replications and counter-results are especially welcome.
Resources: API Reference | Recipes | Architecture | Benchmarks | FAQ | Roadmap
# Clone the repo
git clone https://github.com/zensation-ai/zenbrain.git
cd zenbrain
# Install dependencies
npm install
# Run tests
npm test
# Build all packages
npm run buildResearch
ZenBrain's architecture and algorithms are documented in an open-access technical disclosure:
arXiv preprint (cs.AI): arxiv.org/abs/2604.23878
Open-access archive: ZenBrain: A Neuroscience-Inspired 7-Layer Memory Architecture for Autonomous AI Systems (Zenodo, DOI: 10.5281/zenodo.19353663 — resolves to the latest version)
Current version: version 9 (31 October 2026), Zenodo 10.5281/zenodo.23832288; arXiv:2604.23878v4
TDCommons: Technical Disclosure (CC BY 4.0)
HuggingFace: Model Card & Benchmarks
If you use ZenBrain in academic work, please cite:
@misc{bering2026zenbrain,
title = {ZenBrain: A Neuroscience-Inspired 7-Layer Memory Architecture for Autonomous AI Systems},
author = {Bering, Alexander},
year = {2026},
eprint = {2604.23878},
archivePrefix = {arXiv},
primaryClass = {cs.AI},
doi = {10.5281/zenodo.19353663},
url = {https://arxiv.org/abs/2604.23878}
}Cited by
Five works cite ZenBrain (as of 28 September 2026): a survey by the Sico team at Microsoft Research, MindMemOS by Huawei's Noah's Ark Lab, the EVD preprint, the HindsightTag manuscript and the Lamperouge manifesto.
Agentic Evolution: From Self-Improving Agents to Co-Evolving Human-AI Systems, a survey by the Sico team at Microsoft Research (2026), calls forgetting "critically understudied": very few of the roughly 100 Memory & Sense papers it surveys implement explicit forgetting. It lists ZenBrain as one of four works in its forgetting/lifecycle group and as its only source for sleep-based consolidation.
MindMemOS (Huawei's Noah's Ark Lab, arXiv:2608.12428, August 2026) relies on exactly three references for the foundational claim of its introduction: two field surveys and a single system paper — ZenBrain.
HindsightTag (Vivek Govindbhai Dudhat, manuscript, July 2026, revised 30 September 2026) discusses ZenBrain as its closest prior system and uses its
MemoryCoordinatorinterface as the integration example.EVD: An Emotional Valence Dimension for Persistent Agent Memory (R. J. Vandelinder and I. Vandelinder, Exile Research, Zenodo, June 2026) places ZenBrain in its related work.
The field measures the wrong thing (Lamperouge, manifesto, Zenodo, August 2026) selects ZenBrain among six works on persistent internal state and notes that its "days" are simulation steps.
Each work with the sentence that cites ZenBrain: zensation.ai/en/publikationen.
Projects that build the library into their code:
ACMS reads and writes the ZenBrain SQLite database directly.
neurograph-runtime uses the FSRS-style implementation of
@zensation/algorithmsas the ranking and feedback layer of a knowledge base on radiotherapy literature.
Citing ZenBrain or building on it? Open an issue and we will add you here.
Community
GitHub Discussions: Ask a question, show what you built — help, show-and-tell, feature requests
GitHub Issues: Bug reports & feature requests
Email: open-source@zensation.ai
License
Apache 2.0 — use it in production, modify it, distribute it. Just keep the attribution.
Available Tools
5 toolszenbrain_consolidateConsolidate memoryADestructive
Run one consolidation pass: among the 100 most recent episodes, each one with an emotional weight above 0.5 becomes a semantic fact — once, however often the pass runs. Working-memory slots lose relevance with age, and slots whose relevance has dropped to 0.01 or below are removed; that is the only deletion, and nothing in long-term memory is deleted. Run it between sessions or after a batch of zenbrain_store calls, not on every turn; compare zenbrain_health before and after to see the effect.
Inputs: no named parameters. Returns: pruned, decayed, promoted
zenbrain_forgetForget a memoryADestructiveIdempotent
Permanently delete a memory, addressed by the id and layer that zenbrain_recall returned for it, together with what consolidation linked to it; this cannot be undone. Forgetting an episode also deletes the fact zenbrain_consolidate made from it; forgetting such a fact also deletes every episode consolidated into it; both also delete the working-memory copies of that content. Forgetting a working-memory result deletes only that copy. alsoForgotten lists everything deleted besides the memory itself. A memory stored on its own and never consolidated keeps its long-term entry. Use it when the user asks to forget something or a stored memory is wrong; to correct a memory, forget it and store the corrected version with zenbrain_store. An id the layer does not hold is reported as not forgotten, not as an error.
Inputs: id (required), layer (required). Returns: id, layer, forgotten, alsoForgotten
zenbrain_healthInspect memory stateARead-only
Report how full the memory layers are: working-memory slots in use, interactions held, episodes, facts and how many are due for review, procedures, core blocks. Read-only and cheap, safe to call at any time. It returns counts only; to read the memories themselves, use zenbrain_recall.
Inputs: no named parameters. Returns: core, working, episodic, semantic, +2 more
zenbrain_recallRecall memoriesARead-only
Search long-term memory for anything relevant to a query. By default it searches the episodic, semantic, procedural and core layers; working memory (the most recent stores, held only while the server runs, up to five results) is searched only when named in layers. Returns results sorted by score, each with its id and the layer it came from; zenbrain_forget takes both. The score runs from 0 to 1 and says how well a result matches the query; a layer in which nothing matches returns recent memories (or its most successful procedures) at 0, behind every hit, and minScore above 0 leaves them out. Every core block scores 0.5 or 0.8, so a block can rank above a weak hit. Use this before answering when the user refers to something from an earlier session. To see how much is stored rather than what, use zenbrain_health; to save something, use zenbrain_store.
Inputs: query (required), limit, layers, minScore, +1 more. Returns: count, results, skipped
zenbrain_storeStore a memoryA
Write something into long-term memory so it survives this conversation. Routing is automatic by default, first match wins: steps, or wording such as "How to", "Steps:" or "workflow:", make a procedure; an emotional weight above 0.5 (detected, or set via emotionalWeight) an episode; a confidence above 0.9 a pinned core memory; anything else a semantic fact. Set type only when you want to override that. Every call adds a new memory, except that storing the same core memory again updates it; the content is also kept in working memory (the most recent seven) while the server runs, so once seven are held each store replaces the oldest copy there. Long-term memory is never changed by a store. Returns the id of the stored memory. If it may already be stored, check with zenbrain_recall first: storing it again adds a duplicate.
Inputs: content (required), type, steps, tools, +5 more. Returns: id
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 5 tools
Each tool owns a clearly distinct verb-resource: store (write), recall (read), forget (delete), consolidate (maintenance pass), and health (read-only stats). The descriptions actively disambiguate by cross-referencing each other (e.g. 'to save, use zenbrain_store; to see how much is stored, use zenbrain_health'). No two tools could reasonably be confused.
All five tools follow a uniform zenbrain_<operation> snake_case pattern with single, predictable operation tokens. The convention holds throughout, with no mixing of styles or verb forms.
Five tools is well-scoped for a memory server, with each tool earning its place across a full lifecycle (write, read, delete, consolidate, monitor). Nothing is redundant or missing a corresponding slot.
The surface covers the full memory lifecycle: create (store), read (recall), delete (forget), maintenance (consolidate), and observability (health). Direct update/edit is absent, though it is explicitly documented as a forget-then-store workaround, so it's a minor gap rather than a dead end.
Maintenance
Related MCP Connectors
InfoLang semantic memory MCP — investigate, memorize, and recall compressed agent context.
Long-term memory for AI agents. Pass one sentence, and it remembers, recalls, or forgets.
Simple agent memory MCP: keep, recall, update, forget; shared team graph on Maindex.
Persistent, inspectable memory for AI agents with lineage, correction, and a hosted MCP endpoint.
Related MCP Servers
- AlicenseAqualityCmaintenanceEnables AI agents and MCP clients to store, retrieve, and manage bi-temporal, graph-aware facts in an embedded SQLite memory engine with token-budgeted recall and contradiction tracking.61MIT
- AlicenseNot gradedqualityBmaintenancePersistent long-term memory for MCP clients. Store and recall semantic facts, episodic events, and task state with vector-based relevance search. Write what matters, retrieve what's needed — memory that persists across sessions and agents, backed by a local SQLite store with optional embeddings for meaning-based lookup. Simple file-based storage, no external services required.MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to store and recall durable facts, decisions, and lessons over MCP using hybrid semantic and keyword search, typed memories, graph relations, sessions, and time-travel queries. Runs locally with no server process or API key, persisting everything to files that both agents and a CLI can share.20 npmMIT
- AlicenseNot gradedqualityAmaintenanceGives every AI agent a shared, persistent memory by ingesting Obsidian vaults, code, transcripts, bookmarks and terminal sessions into a three-tier SQLite FTS5 store, then serving token-optimized hybrid retrieval, classification, promotion and cross-source synthesis over MCP and REST. This lets multiple agents read from and write to one compounding brain so each session starts with better context than the last.10 npmMIT