DEV Community: Richard Emate

Your AI agent shouldn’t flinch at every tiny change, but it also shouldn’t treat a career switch like background noise. This post asks what happens when you treat “experience” as leftover surprise: the part of reality your model did not already see coming.

Richard Emate — Tue, 18 Aug 2026 15:54:50 +0000

Richard Emate

Aug 18

How a theory of leftover surprise changed a memory layer

#python #ai #llm #opensource

9 min read

How a theory of leftover surprise changed a memory layer

Richard Emate — Tue, 18 Aug 2026 12:30:00 +0000

Consciousness Might Not Look Like Anything

If you are looking for consciousness in behavior, you may be looking at the wrong thing.

The system most in contact with the world need not flinch, chatter, or otherwise announce that something happened. It may look, from the outside, as if nothing did.

The obvious claim is the opposite: the most conscious being is the one whose internals get shoved around the hardest. Raw sensitivity. Volatility as contact. A thermostat kills that story. Turn the heat on and its state flips. Nobody thinks it is more conscious than a rock. Disturbability is cheap.

What matters is the structure of the response — a large repertoire of distinguishable states, produced by one system you cannot carve into independent parts without losing something. A bundle of switches is many parts and no unity. A single wire is total unity and two possible states. Neither is interesting.

Even that is not quite the target. The interesting system is not the one that gets pushed around a lot. It is the one that can absorb a wide range of perturbations while remaining itself — and, more than that, can see them coming so the jolt never fully arrives. Internal change is a side effect of regulation, not the point. Paradoxically, a more competent system may look calmer, not more volatile. It is absorbing disturbance predictively. From the outside there may be nothing to watch.

That is the sense in which consciousness might not look like anything.

I did not set out to settle that question. I set out to stop an agent from treating a career change like noise and a passing mood like a personality transplant. The philosophy showed up anyway. Then it earned its keep.

Two kinds of regulation

Homeostasis waits. Deviation is detected, then corrected toward a fixed setpoint.

Allostasis moves the setpoint first. The target is anticipated, context-dependent, allowed to shift. Blood pressure before you stand up. The coat before the cold. Peter Sterling’s version is blunt: waiting for error and then fixing it is inefficient.

The interesting quantity is not how much allostasis a system has as a fixed amount. It is the range it can cover: how far ahead it can act, how many setpoints can move independently, how much of the space of possible contexts actually drives those moves. Each of those is near-useless without the others. Horizon without retargetability is a longer reflex. Retargetability without context is a clock.

Experience, on the strongest reading of the same literature, is not the regulation itself. It is the leftover: the part of the world the model failed to anticipate. Prediction error after the coat was already on. The same stimulus should feel vivid at first and thin out as the prediction improves. Habituation is the residual shrinking.

That is a trigger condition, not a solution to the hard problem. I am not claiming a Python library is conscious. I am claiming the split is load-bearing for any memory that has to stay current without coming apart.

One number was doing two jobs

VoltMem already had a prior about how stubborn each kind of fact should be. Personality locks down. Mood is cheap. A job sits in between. That prior is a slow allostatic signal: this channel is usually like that. It is not a reading of what is happening now.

A live residual would ask a different question. Given what we already expected — including that this channel is usually noisy, or usually quiet — did this observation arrive in a way we had not already priced in?

A domain can be historically messy and currently well-predicted. Under one scalar those cases are the same. They should not be.

The old overwrite rule charged that stubbornness twice. Being a “rarely changes” kind of fact both shrank the evidence and raised the bar. For a job, a clear “I retrained as a nurse” could fail to overwrite “I was a data analyst.” It was not being careful. It was double-counting the same caution.

So we built an allostatic mode: drop volatility from the evidence score, and let recent leftover surprise temporarily lower the bar for memories that are going through something.

The first ablation was rude. The entire career-change win was taking volatility out of the score. It was a cliff, not a blend. A little volatility left in the formula lost the case entirely.

That looked like a free improvement until we measured the cost.

The defect was insurance

The classifier that guesses “what kind of fact is this?” is about 84% accurate. When it files a personality trait as something more changeable, and a weak comment arrives, allostatic mode overwrites. The double charge we had just called a bug still discounts the evidence, and the trait survives.

At the real error rate, allostatic lost 1.1 points of accuracy and produced 20% more false updates. Every extra overwrite had the same shape: a very-stable fact, mislabeled, contradicted by weak evidence.

Removing the double charge fixes career changes and breaks mislabeled traits. It is a genuine trade. You cannot slide volatility halfway back in; we already measured that cliff. The remaining honest move is a switch, not a mix.

Most of the time the system stays homeostatic: this is the kind of fact it is; I need a lot of proof. It goes allostatic when the world is actually telling it the setpoint moved — a clear correction, or a leftover it did not already expect.

That switch is now the default in VoltMem 0.4.0. It is called composite. It matches the cautious law’s false-update rate and still catches the explicit career change. Allostatic stays available if you pass a trusted domain label and want the residual path all the time. Homeostatic stays available if you want the insurance always on.

A theory of range, not amount, said a channel should be able to move between modes rather than carry one weight for its lifetime. The gate is that claim, implemented as a predicate instead of a personality.

We were measuring the thermostat

The live shakiness meter was an average of raw contradiction — how different the new sentence was from the stored one. Every method in the notes treats surprise as leftover mismatch after anticipation. We were scoring the flinch.

If someone has been casually mentioning a new job for two weeks, another casual mention is not surprising. If they have been quiet for months and then say the same words, that is surprising. Same sentence. Different leftover.

We shipped that definition. Each memory keeps a running “what mismatch size is normal,” widened by how noisy the domain usually is. Surprise is distance from that prediction, not from the stored sentence. Evidence still uses how contradictory the sentence is. Surprise uses how unexpected that contradiction was.

The career change said clearly still works. It never needed the surprise term. It wins by dropping the double charge.

The sixteen weak asides stopped catching live. After a few similar mentions the system expects them. Leftover goes to zero. The bar stays shut. That is the definition working, which is why it could not be the slow-burn fix. People do not rewrite “my job” on every aside. They notice the pattern later.

We had been celebrating a hairline. An average of raw contradiction had been sitting 0.0002 from the trigger; stretching the half-life from two weeks to a month shoved it over. That is not surprise. That is a constant wearing a costume.

The pile belongs overnight. Sixteen daily weak mentions stay quiet on the write path, then consolidation actually supersedes the stored job. The same sixteen spread monthly do not. A core preference does not yield. Same evidence, same count, only the pace differs. That is horizon: identical evidence at different spacing must not count the same. An earlier version keyed shakiness to a lifetime counter that could only ratchet open. A long-lived memory would have grown permanently easier to overwrite with age. Time decay was the route back to settled. Range requires a way home.

So 0.4.0 has three timescales, not one knob:

Live leftover — was this step unexpected? Quiet is correct.
The gate — explicit correction, or a leftover we did not already expect, opens the easy-update path. Otherwise keep the insurance.
Sleeptime — has the belief that the old fact still holds actually moved, over a window? Daily weather can shift a job overnight. A monthly drip cannot. A deep preference does not erode.

That is the sleeptime compute idea from a previous post, now with a detector that sees spacing instead of a counter that never forgets.

Then we found the thing sitting in front of all of it

None of the overwrite work runs if the new sentence never finds the memory it contradicts.

The matcher and the overwrite rule are sequential, not alternatives. Homeostatic vs allostatic only starts after a match. A miss inserts a duplicate. A false pair does consult the overwrite law — on the wrong memory.

Through the default remember() path, keyword similarity routed 22% of update cases. A real embedder routed 78% with perfect labels, 56% with the shipped classifier. Decision error once routed was about six points. We had been arguing about the six-point layer. Two of the cases that never linked even with embeddings were the exact career-change and goal-change probes allostatic was built to recover.

The obvious repair is to lower the link bar. That repair is forbidden.

“User is proficient in Python” versus “User is proficient in Japanese” scores as a stronger match than “I was a data analyst” versus “I retrained as a nurse.” The false merges outrank the true links. No cutoff can work. Bag-of-words and sentence embeddings both encode topic, not entity identity. They cannot tell two facts about family members from one fact restated.

A duplicate is recoverable. Both facts stay retrievable; a later pass can reconcile them. A false merge treats two different facts as one and loses a true memory. Lowering a bar converts the cheaper error into the expensive one.

Worse: under a threshold ladder, improving the classifier makes data loss worse. Correct labels put two distinct facts in the same slot, where the ladder can merge them. Misclassification was accidentally protecting memories by scattering them.

The architecture that survived is recall wide, decide narrow. Similarity is allowed to fetch candidates. It is not allowed to decide “same fact.” A conservative local model looking at the pair — same subject? same question, never the same answer? — scored 49/56 on held-out pairs with zero false merges. A hosted model scored three pairs higher and paid for it with two irreversible losses. Under the weighting we used everywhere else, that is a bad trade. We kept the conservatism.

A 14B call is about five seconds. Fine overnight. Too slow inside an interactive remember(). The worst case of deferring it is a temporary duplicate. That is what makes deferral acceptable rather than a compromise.

So the shipped write path is millisecond and conservative. Heuristic subject/attribute frames we trust may join. Grey frames insert as twins. Overnight, the local verifier reconciles them. Live remember() does not wait for the 14B unless you ask it to.

The philosophy said leftover only appears at the edges where the model is under-fit. In the library, leftover only appears at all if the observation finds the slot. The matcher is not a theory of consciousness. It is the condition under which the control law, and therefore any residual, is even computed.

What 0.4.0 actually is

The consciousness writeup was a searchlight, not a control law. It made us split expected noise from unexpected leftover, refuse raw dynamism, refuse a lifetime weight, refuse a blend, and notice that a miss never consults the overwrite rule. The range formula did not have to be true for those moves to pay. Neither did “this is what experience is.”

What shipped:

Surprise means unexpected leftover, not how different the sentence is. A predicted weak stream no longer impersonates a regime change.

Composite overwrite — cautious by default; allostatic only on an explicit correction or a learned unexpected residual. Career changes said clearly get through. Mislabeled traits keep the insurance.

Sleeptime for the pile — daily weak evidence can move a belief overnight; the same evidence dripped monthly does not. Very-stable domains do not erode.

Search widely, decide narrowly — embeddings for recall, a conservative local verifier for precision, deferred to sleeptime. Duplicates are okay. Silent overwrites are not.

If you're building persistent agent memory

Three distinctions paid rent. I would steal those and leave the rest.

Contradiction is not surprise. Distance from the stored fact is an observation. Surprise is distance from what you had already predicted, scaled by how noisy that channel usually is. If you average raw mismatch until it crosses a bar, you will eventually "catch" a slow change by sitting on a hairline. That is not a capability.

A switch, not a blend. If two control laws win on different failure modes, mixing their formulas can lose both. Gate on the kind of evidence. Keep the insurance for weak noise on a guessed label. Spend the plasticity on a clear correction or a leftover you did not expect.

The matcher is in front of the overwrite rule. Improving when to update a fact does nothing for a sentence that never found it — and does the wrong thing for a sentence that found the wrong one. Rank topic similarity and entity identity separately. Weight errors by whether they can be undone. If your "better embedder" starts deleting stored facts, you did not improve matching. You changed which mistake you make.

A thermostat looks alive. A system that saw the perturbation coming may look like nothing happened. VoltMem’s write path is now allowed to look like that on purpose: millisecond, quiet, twins instead of guesses. The work happens at the edges, and overnight.

I still do not think that makes it conscious. I think it makes it less of a thermostat.

The Maintenance Window I Didn't Know I Was Running

Richard Emate — Fri, 07 Aug 2026 07:26:58 +0000

How Letta's sleep-time compute reframed VoltMem's open problems

I didn't set out to build a memory layer for LLM agents.

What I set out to build was a way to stop being frustrated by agents that forget the right things and remember the wrong ones. The Berlin → Paris problem: your agent knows you live in Berlin. You move to Paris. Three months later it's still asking about Berlin weather. Meanwhile, your stable preference for concise answers — something you've held for years — gets overwritten by a single offhand comment because the system treats all facts as equally volatile.

That frustration became VoltMem, a memory layer that assigns domain-specific volatility priors: personality traits get locked down, locations update freely, current tasks evaporate quickly. The math works. The benchmarks validate it. VoltMem is a control knob on the stability-plasticity tradeoff, not a free-lunch accuracy booster — and that's exactly what it was supposed to be.

But building it surfaced problems I hadn't prepared to answer. Four of them, tracked in docs/OPEN_PROBLEMS.md:

Classification brittleness — write-time labeling of facts is its own judgment call, and if the label is wrong, everything downstream is wrong.
Stable facts that genuinely change — protection against noise also blocks legitimate updates that build slowly across multiple observations.
Under-specified retrieval — when queries are vague, similarity scores flatten and volatility re-ranking can pick the wrong winner.
Multi-facet events — real observations carry multiple signals at once (location, task, emotional state), but VoltMem assumes one fact, one domain.

These aren't edge cases. They're the gap between a memory layer that works in demos and one that survives contact with reality.

The rabbit hole

Sometime around when Problem 2 was driving me quietly insane — watching the escalation math correctly reject a noisy blip but also miss a legitimate career change that emerged across four casual mentions over two weeks — I found myself reading everything Letta had published on agent architecture and continual learning.

That path led to their post on sleep-time compute: a dual-agent design where a primary agent stays responsive in conversation while a separate sleep-time agent runs asynchronously to consolidate, reorganize, and rewrite shared memory blocks. The point isn't to invent new facts during idle time. It's to offload memory management from the hot path so formation can be proactive instead of incremental and messy.

I wasn't looking for a VoltMem roadmap. I was looking for language for a gap I already had.

Sleep-time compute, simply

Most agents have excellent working memory and no long-term maintenance loop. Between sessions they are simply off. Sleep-time compute uses those gaps — or dedicated background cycles — to:

Process and distill what happened during active sessions
Integrate new memories with old ones
Notice contradictions that weren't visible in real time because real-time cognition is too narrow
Build associative structure that only emerges from distance and pattern

It's not about adding new information. It's about reorganizing what you already have.

The analogy that made this click for me is ordinary human downtime: shower thoughts, late-night drift, the moments where you're not deciding anything and somehow end up filing yesterday's half-finished thoughts against older patterns. That isn't rest in the useful sense. It's maintenance on the index. Agents mostly skip that phase.

Mapping sleep-time to VoltMem's open problems

Sleep-time compute isn't a silver bullet. But it directly addresses the hardest of VoltMem's four open problems — and incidentally helps with two others.

Problem 2: Stable facts that genuinely change ← The primary match

This is where the idea shines brightest.

The core tension in VoltMem's escalation math is: don't corrupt on noise vs don't miss a real change. The current system handles this at write-time: when new evidence arrives, check if E_t > θ_t, and if so, escalate to audit + update. Explicit statements with high mismatch magnitude can override stable-domain protection.

But some changes don't arrive as dramatic contradictions. They emerge as patterns across multiple weak observations. Like: the user mentions "my new job" casually in 4 conversations over 2 weeks. Each individual mention is weak evidence. None cross the threshold alone. The escalation math, correctly calibrated to reject noise, also misses the signal.

A maintenance window catches this. During idle cycles, the system can review the full logged_mismatch history. Those 4 weak "new job" mentions, none strong enough to trigger a real-time audit, combine into a clear pattern during offline analysis. The system can then proactively escalate the career-change audit — possibly even flagging it for user confirmation before the next active session begins.

This is exactly the gap: the escalation math is reactive (new evidence arrives → check threshold), while some changes are emergent (pattern builds over time → need retrospective review).

Problem 1: Classification brittleness ← Partial, but real

At write-time, VoltMem assigns a domain via keyword heuristics or a local LLM. If "I feel great today" gets labeled emotional_context (correct) or core_preference (wrong), the volatility prior is wrong and everything downstream is wrong.

A maintenance loop adds a correction pass. During idle cycles, the system can re-classify ambiguous facts using richer context — the full conversation history, not just the turn where the fact was extracted. A label assigned based on fragmentary evidence at write-time might look obviously wrong when reviewed alongside three months of consistent contradictory observations.

This doesn't fix the initial brittleness. But it adds a nightly audit: "these 47 facts got labeled core_preference but only 3 have ever been audited, while 12 have been contradicted multiple times. Are some of them actually emotional_context or current_task?"

Problem 4: Multi-facet events ← Architectural enabler

Real utterances carry multiple signals. "I'm exhausted but heading to the gym in my new apartment" contains emotional state, current task, and location — plus an implicit causal link between them.

At write-time, processing this into multiple facets is expensive and error-prone. Most systems (including VoltMem today) pick one domain and move on.

A maintenance window separates the tradeoff. During idle cycles, the system can re-parse rich utterances into multiple linked facets, assign per-facet volatility, and link them under a shared event_id — all without blocking the write path. The user gets fast, simple storage. The agent gets rich, linked structure after hours. This is essentially the multi-facet add_event() API proposed in OPEN_PROBLEMS.md, but implemented asynchronously rather than synchronously.

Problem 3: Under-specified retrieval ← Weaker connection

When queries are vague ("what was I working on?"), similarity scores flatten and VoltMem's volatility re-ranking can invert ranks incorrectly. Background integration helps indirectly here: by building associative structures during idle hours — noticing that "database migration" co-occurs with "current_project" 80% of the time, or that certain task memories cluster around specific project phases — the retrieval system gets richer linkage to fall back on when raw similarity is uninformative.

But this is the weakest connection. The core issue in Problem 3 is query specificity, and sleep-time doesn't make queries more specific. It just gives the retrieval system more paths to follow when the direct path is muddy.

What this changes for VoltMem

Reading Letta's work reframed my open issues.

The product claim isn't "agents should sleep like brains." It's narrower and more useful:

Memory layers need an explicit maintenance surface for operations that are too expensive, too speculative, or too context-heavy for the write path.

Async support for VoltMem isn't just about not blocking the event loop — it's about whether the memory layer can survive being left alone for hours and come back integrated. Smarter domain classification isn't just about better heuristics — it's about whether the classification itself gets refined during the gaps.

That principle is what the next VoltMem cycle operationalizes: ship the enabling API (event_id, multi-facet events, optional TTL), then populate a maintenance runner task by task — pattern audits on logged mismatches, ambiguous reclassification, expire cleanup — without pretending VoltMem is a full sleep-time agent architecture.

A note on scope

I don't think VoltMem's next version will literally implement Letta's sleep-time agents — that's a full system architecture, not a memory layer feature. But the principle is seeping into the roadmap.

The question isn't "should VoltMem run background threads?" The question is: what maintenance operations does a memory layer need that are too expensive, too speculative, or too context-dependent to run at write-time?

Retrospective pattern detection on logged mismatches? Maintenance.
Domain relabeling with full historical context? Maintenance.
Multi-facet re-parsing of rich utterances? Maintenance.
Building cross-referential links that only emerge from co-occurrence over weeks? Maintenance.

These are the gaps VoltMem has. Sleep-time compute is one architecture for filling them. VoltMem's next step is the smaller, portable version: a maintenance window the memory layer can own.

If you're building persistent agent memory

The sleep-time compute idea is worth your attention. Not because it's a quick win — it's harder than it sounds to do well — but because it names a real gap: most of our agents have excellent working memory and no long-term maintenance loop.

An agent that only learns when the user is present is like a person who only thinks when someone else is talking. The quiet hours matter. The maintenance window is where integration happens. Without it, you get either brittleness (too rigid) or corruption (too plastic) — and the escalation math alone can't solve both.

And if you too spend a suspicious amount of time reorganizing thoughts you didn't finish yesterday — you're not broken. You're running the index.

VoltMem on GitHub · Original VoltMem writeup · Letta: Sleep-time Compute · Built by Richard Emate

I Built a Memory Layer for LLM Agents That Knows Which Facts Go Stale

Richard Emate — Mon, 13 Jul 2026 01:42:18 +0000

VoltMem didn't start because I kept hitting bugs in production agents.

It started with a conversation about how memory actually works — why some beliefs stick for decades while others evaporate in hours, and what triggers the audit when an old calibration stops matching present reality. That led to continual-learning research on the stability–plasticity tradeoff, and then to a structural parallel in agent memory: most layers treat every fact the same at write and search time.

The Berlin → Paris Problem
Most memory systems treat "I live in Berlin" (volatile) with the same protection as "I prefer concise answers" (stable). VoltMem differentiates them by domain.

Your AI assistant knows you live in Berlin. You moved to Paris three months ago. It still thinks you live in Berlin. Meanwhile, the fact that you prefer concise answers — stable for years — gets the same grip as "currently working on a database migration," which you finished last week.

Everything is stored the same way. Everything decays (or doesn't) at the same rate. There's no concept of how volatile a piece of knowledge actually is.

Mem0 remembers relevant facts. VoltMem remembers current truth.

The Core Insight
The Math
What it Looks Like in Practice
Using it
Built-in Domain Volatility Priors
LangChain Integration
Where This Came From
What's Next

The core insight

Think about how different types of facts actually behave over time:

Your personality traits — barely change over decades
Core preferences (communication style, aesthetic sensibilities) — stable for years
Your job — changes every few years
What you're currently working on — changes weekly
Your mood right now — changes hourly

An LLM memory system that treats all of these with the same protection strength makes systematic errors in a predictable direction: it holds volatile facts too long (stale knowledge), or overwrites stable facts on thin evidence (corrupted knowledge). You can't fix both with one dial.

What you need is domain-aware protection — and, at search time, down-ranking of stale volatile memories even when they're semantically close.

The math (stay with me, it's not that bad)

Protection weight (per domain):

w_{d} = \frac{1}{V _{d γ}}

Write / audit decision — escalate (audit + update) when $E_{t} > θ_{t}$ :

E_{t} = [\frac{M _{t} \cdot R _{t}}{C ^{α}}] \cdot V_{d} \cdot G_{t} θ_{t} = \frac{θ _{0}}{V _{d}} \cdot L_{t}

Where:

$M_{t}$ — how strongly the new observation contradicts what's stored (0 to 1)
$R_{t}$ — how reliable the source is (explicit user statement vs. weak inference)
$C$ — how many times this memory has been confirmed (repetition count)
$α$ — entrenchment exponent (how hard history fights back)
$V_{d}$ — domain volatility prior (how fast does this type of fact change?)
$G_{t}$ — goal-attainment delta (is updating this memory actually useful?)
$L_{t}$ — cognitive load

High-volatility domain → low threshold → easy to update.
Low-volatility domain → high threshold → hard to update.

Retrieval — down-rank stale volatile memories:

score = similarity \cdot (1 - V_{d} \cdot staleness)

The practical effect: a confident blip like "the user seemed extroverted today" won't overwrite a deeply confirmed "user is introverted" — but "user moved to Paris" will cleanly supersede "user lives in Berlin" because location is a volatile domain where a single explicit statement clears the update bar easily.

On Split-MNIST, this isn't a free-lunch accuracy booster. It's a validated control knob: run the same pipeline with volatility priors shuffled or inverted, and the ordering breaks (REAL > SHUFFLE > SWAP). Pre-arXiv draft: volatility_ewc_portfolio.pdf. Full reproduction: docs/RESEARCH.md.

What it looks like in practice

I compared VoltMem against Mem0 (open-source LLM memory) on three concrete scenarios — a case study, not a leaderboard claim:

Scenario 1: Location update
User says they moved from Berlin to Paris.

	Mem0	VoltMem
Result	Stale "Berlin" stored, 2 conflicting facts	Updated to "Paris", 1 clean fact

Scenario 2: Stable preference blip
User says they "really like short replies" in one session, contradicting an established preference for thorough explanations.

	Mem0	VoltMem
Result	Adopts the blip	Keeps original (resists weak contradicting evidence)

Scenario 3: Volatile mood
User's mood shifts from "great" to "stressed".

	Mem0	VoltMem
Result	Stale "great" persists	Updates to "stressed"

VoltMem: 3/3 current top answer on these scripted scenarios. Challenge the scripts:

python experiments/mem0_side_by_side.py

Retrieval haystack (same chunks, different ranker): cosine-only returns the stale fact first 20% of the time; VoltMem 0% stale@1.

python experiments/retrieval_haystack_bench.py

LongMemEval-S (n=60): 70% answer@5 — ties cosine, does not beat it. If your only metric is public benchmark SOTA, this isn't the pitch. The pitch is update policy + retrieval freshness on mixed-volatility personal memory.

python experiments/longmemeval.py --split s --per-type 10

Using it

pip install voltmem[embeddings]

Core library: zero required dependencies. Embeddings optional (sentence-transformers).

from voltmem import create_memory

mem = create_memory("app.db", user_id="alice")

mem.add("I live in Berlin")
mem.add("I prefer concise, direct answers")
mem.add("Actually I moved to Paris last month")   # updates location, not prefs

hits = mem.search("where does the user live?", limit=3)
print(hits[0]["memory"])   # "Actually I moved to Paris last month"

Inject into any LLM system:

memories = mem.search(user_message, limit=5)
context = "\n".join(f"- {m['memory']}" for m in memories)
system = f"What you know about this user:\n{context}"

Built-in domain volatility priors

VoltMem ships with sensible defaults you can override:

Domain	Volatility	Behavior
`personality_trait`	0.05	Strongly protected
`core_preference`	0.08	Strongly protected
`biographical`	0.10	High protection
`professional_context`	0.30	Medium — changes every few years
`current_project`	0.55	Updates readily
`emotional_context`	0.80	Fast-moving
`current_task`	0.90	Minimal protection

Custom domains:

from voltmem import create_memory, DomainRegistry

domains = DomainRegistry()
domains.register("client_relationship", 0.35)
domains.register("active_deal_stage", 0.70)

mem = create_memory("crm.db", user_id="rep_01", domains=domains)

The priors are hand-tuned today — that's an open gap, and one of the places I'd most like real-world feedback.

LangChain integration

pip install voltmem[langchain]

from voltmem.integrations.langchain import VoltMemMemory

memory = VoltMemMemory(session_id="user-42", db_path="app.db")
memory.load_memory_variables({"input": "Where do I live?"})
memory.save_context({"input": "I moved to Paris"}, {"output": "Noted."})

Where this came from

This grew out of a philosophical conversation about how human minds handle stale beliefs — when to trust an old habit and when to question it.

The observation: animals mostly rely on impulses and simple reinforcement to build routines. Human minds add a monitoring layer on top — but that layer can go wrong when calibrated by social contexts that no longer apply. An old rule, reinforced enough times in a specific environment, can feel like an unquestionable fact even when the environment has fundamentally changed.

That maps almost exactly onto the LLM memory problem. A memory system calibrated by early conversation data can become rigid in the same way — protecting old "truths" that are now stale because they were confirmed enough times in the past.

The escalation equations above formalize the same idea: use historical reinforcement as one input, but also factor in domain volatility, source reliability, and actual mismatch — rather than letting any one factor dominate. The continual-learning experiments validated that as a causal control knob; VoltMem is the engineering artifact applied to agent context memory.

What's next

More benchmark scenarios — expanding beyond the 3-scenario Mem0 comparison, including cases where VoltMem loses
Smarter domain classification — heuristics and optional Ollama LLM work today, but priors are hand-tuned and new domains still need manual registration; next up is better defaults, cloud LLM support, and inferring domain + volatility from context
Async support — sync store today; most production LLM apps are async
arXiv preprint — theoretical foundations written up; submission in progress

Try it

pip install voltmem[embeddings]
python examples/contradiction_demo.py
python -m examples.chat_app

GitHub: https://github.com/Rouche01/voltmem
PyPI: https://pypi.org/project/voltmem/
Research & repro: https://github.com/Rouche01/voltmem/blob/main/docs/RESEARCH.md

If you're building anything with persistent LLM memory, I'd genuinely like to hear how the stale-knowledge problem shows up in practice — the use cases I haven't thought of are usually the most interesting ones.

Check out VoltMem on GitHub and leave a Star!

DEV Community: Richard Emate

Your AI agent shouldn’t flinch at every tiny change, but it also shouldn’t treat a career switch like background noise. This post asks what happens when you treat “experience” as leftover surprise: the part of reality your model did not already see coming.

How a theory of leftover surprise changed a memory layer

How a theory of leftover surprise changed a memory layer

Consciousness Might Not Look Like Anything

Two kinds of regulation

One number was doing two jobs

The defect was insurance

We were measuring the thermostat

Then we found the thing sitting in front of all of it

What 0.4.0 actually is

If you're building persistent agent memory

The Maintenance Window I Didn't Know I Was Running

How Letta's sleep-time compute reframed VoltMem's open problems

The rabbit hole

Sleep-time compute, simply

Mapping sleep-time to VoltMem's open problems

Problem 2: Stable facts that genuinely change ← The primary match

Problem 1: Classification brittleness ← Partial, but real

Problem 4: Multi-facet events ← Architectural enabler

Problem 3: Under-specified retrieval ← Weaker connection

What this changes for VoltMem

A note on scope

If you're building persistent agent memory

I Built a Memory Layer for LLM Agents That Knows Which Facts Go Stale

Table of Contents

The core insight

The math (stay with me, it's not that bad)

What it looks like in practice

Using it

Built-in domain volatility priors

LangChain integration

Where this came from

What's next

Try it