ZenBrain Memory

• arXiv preprint (cs.AI): arxiv.org/abs/2604.23878
• Open-access archive (Zenodo / CERN): doi.org/10.5281/zenodo.19353663
• 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 [email protected].

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 15 neuroscience-inspired mechanisms — 9 foundational algorithms + 6 Predictive Memory Architecture (PMA) components (paper). The six PMA components are proprietary: they ran in the ZenAI 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

On LongMemEval-500, three of nine head-to-head comparisons hold against Letta, Mem0 and A-Mem — all three against A-Mem, the remaining six are ties, none lost. Three competitors x three LLM judges, Bonferroni-corrected (alpha = 0.05/18) and version-matched. The measured ZenBrain arm (per the correction notice a Python port of a test-harness class, not the seven-layer system) reaches 91.3% of the binary-judge accuracy of a full-context comparison arm (whose answer model reads the whole history) with 1/109.6 of its input tokens in the answer step (47.7% vs. 52.2%); building the memory is not counted.

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

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.txt covering 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: [email protected].

How ZenBrain differs from Mem0, Letta and Zep

ZenBrain's architecture combines fifteen mechanisms taken from human memory research: nine foundational algorithms, which are in this library, and six Predictive Memory Architecture components, which are not public. Among the systems the paper surveys, none integrates more than two of the features it compares. 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.

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 FSRS
• hebbian-two-factor — Two-Factor synaptic consolidation
• sleep-simulation-selection — RL-based replay selection
• spectral-health — Fiedler-value KG health monitor
• ib-budget — Information-Bottleneck retention budget
• dopamine-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.

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/[email protected], @zensation/[email protected]) instead of the current one — which looks like a broken package but is a platform mismatch. See CHANGELOG.

npm install @zensation/algorithms

import {
  initFromDecayClass,
  getRetrievability,
  updateAfterRecall,
  tagEmotion,
  computeEmotionalWeight,
  computeHebbianStrengthening,
  propagateForRelation,
} from '@zensation/algorithms';

// 1. Schedule a memory with FSRS
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 confidence

Want the advanced algorithms?

import {
  computeKGPredictionError,
  computeAdaptiveFSRSInterval,
} from '@zensation/algorithms/fsrs-vmPFC';

// Couple FSRS 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):

npx tsx examples/basic-chatbot.ts

The 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 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 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. In @zensation/core every fact gets an FSRS schedule; your application reports each review with recordReview(), and FSRS 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 is 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 review is due; report each review with recordReview()
const dueItems = await memory.getReviewQueue();

Packages

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, the AI platform they ran in production. Everything claimed here is verifiable in this repository:

• 945 tests (539 algorithms · 164 core · 88 adapter-sqlite · 65 adapter-postgres, 12 of them against a real PostgreSQL · 61 mcp · 28 ai-sdk), all passing
• Zero runtime dependencies in @zensation/algorithms and @zensation/core (core depends only on algorithms) — pure TypeScript, dual ESM + CJS, tree-shakeable subpath exports
• Reproducible — building from this source produces the same 153-file @zensation/[email protected] tarball published on npm
• 7-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 build

Research

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)
• 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 MemoryCoordinator interface 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 implementation of @zensation/algorithms as 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: [email protected]

License

Apache 2.0 — use it in production, modify it, distribute it. Just keep the attribution.