DEV Community: Richard Emate

A library is a basis. App code is coefficients. Refactoring is a change of basis. I use compression and sparse coding to pin down what actually counts as a "new idea" — and why frequency, not drama, earns one.

Richard Emate — Wed, 23 Sep 2026 10:21:31 +0000

Richard Emate

Sep 23

A Psychological State is a Coefficient Vector

#computerscience #machinelearning #ai #programming

13 min read

A Psychological State is a Coefficient Vector

Richard Emate — Wed, 23 Sep 2026 10:16:16 +0000

Hamming's two kinds of novelty are not two kinds of stuff. They are two things you can do with one set of building blocks: mix them differently, or add a new one.

Hamming's leftover question

I got stuck on two words in Richard Hamming's The Art of Doing Science and Engineering: logical novelty and psychological novelty.

He mentions them in passing, in a chapter on machines and originality. A program working properly never produces logical novelty, because everything it does was already implied by what you wrote. It produces psychological novelty constantly. You are surprised by your own code. Then he turns the question on us. Much of human discovery looks the same: past experience led you there, the circumstances set it up. And once you fix the postulates, the definitions and the logic, he says, "all the rest of mathematics is merely psychologically novel." He even asks whether logical novelty is possible at all.

We use the two words as if they were one. Psychological novelty is new to you: a thought you had never had, but one always within reach, because someone else already had it or you could have worked it out from what you knew. Logical novelty is new to the space itself. One visits a point in a space that already existed. The other makes the space bigger. Hamming's question, put that way, is whether the second kind ever happens.

New weights versus new directions

I started asking what it would take to make that difference precise, and it turned into a picture.

If "new to you" means a new mix of things you already have, then the things you already have sit there like a set of fixed directions. Call that set a basis. Every ordinary new thought is a new coefficient vector: a different mix of the same directions, a combination you had not worked out yet but that was always available. Logical novelty is not a new mix. It is a new basis vector, a direction that was not in the set, which makes more things reachable instead of visiting somewhere new inside what was already reachable.

There is a third thing you can do, too — keep the same directions but choose better coordinates to describe them in — and I will come back to it, because it is the one that makes Hamming's split hardest to hold.

That does not answer Hamming. It says what logical novelty would have to be: not a surprising combination, but the set of directions itself getting bigger.

Storage, and time

The two layers store differently. A basis vector is cheap to keep, because you do not store what it produces. You store the rule and produce them again on demand. A coefficient is the reverse: cheap to make, expensive to keep, tied to a moment, gone unless something writes it down. Logical and psychological are not two kinds of content. They are two tiers of one storage system.

None of which is mine. The difference between keeping a lookup table and keeping a short program that regenerates it is the founding move of algorithmic information theory, and Kolmogorov complexity is the formal version of storing the generator rather than its consequences. Minimum description length is its practical descendant, and it makes the cost of missing structure concrete: you pay for the model plus whatever the model fails to explain, which in the usual examples is the difference between a description that grows like N and one that grows like log N.

The human version of this is time. A logical thing does not happen on a Tuesday. Whatever gets you 2+2=4 (the axioms, not the answer) is the same tomorrow. That is all I mean by timeless: not a separate world of non-physical objects, and not "maths never changes," just that you do not have to work the rule out again when the clock moves.

A psychological state has a date on it. You live inside the mix: what is recent, what stands out, what happened just before, and the fact that it will fade. Grief has a date. The attachment and the loss it draws on are closer to generators, because they keep producing effects without being the feeling itself. You live through the weather. Generators are why you do not have to store every cloud.

This is also why hard science and social science can feel like different worlds without being made of different stuff. Physics spends most of its effort on rules that survive time, so the details can be thrown away. Much of social science has to keep the diary, because what it studies is tied to context and changes while you watch. That gap is about storage, not about reality, and it closes whenever someone finds structure that regenerates the pattern.

One warning, because it protects the distinction. A generator is timeless once you have it, but the set can still grow. If logical meant "never changes," growth would be impossible, and we would be back to eternal rules sitting above mere feelings.

The state is the recipe

Drawing it helps. A few fixed arrows from one origin, and any psychological state is a single arrow built by weighting them. The state is the recipe, and the dashed lines are the coefficients: how much of each generator is in play right now.

The teal axes do not move. They are the logical layer, timeless once found. The coral arrow has a date, and tomorrow it can point somewhere else while the generators stay put. The same shape turns up elsewhere under other names: a transformer's attention weights against its fixed matrices, or sparse coding's activations against its dictionary.

Two exits

A basis does not arrive from nowhere, and neither does a new basis vector.

Take noisy experience and look for the cheapest structure that still explains it. Most of the time the search just adjusts weights on the basis you have. That is psychological novelty: cheap, constant, the ordinary churn of new mixes. Now and then no mix is good enough, and nothing you have explains the new data however you weight it. Then the system cannot adjust its way out. It has to add a direction.

On the left is a thought you could always have had: same A, same B, different recipe. On the right is the rarer move. A third generator appears because no mix of A and B lands where the state needs to be, and the coral arrow leaves the old plane only because the basis grew. So this is not a hierarchy with rule on top and feeling underneath. It is one loop with two exits, and whichever it takes, the result changes how the next round of experience gets read.

Which exit cannot be settled by how surprised you feel. It needs a cost: fit what you are seeing, but keep the structure small. With no penalty for growing, "add a direction" is always available and the distinction turns into taste. With a penalty, you grow only when squeezing the old directions harder would cost more than admitting a new one.

That cost is also what stops the picture from being a definition in disguise. Arrows and weighted sums are tidier than the real thing, and a few grammar rules will produce sentences nobody has ever said, which can look like the space growing when it has not. So "it was already reachable" cannot be the test on its own. The cost comparison can be.

When an atom pays for itself

Sparse coding is the clearest place I know to watch it, because there the basis is a real object you can point at.

Say you are compressing small patches of photographs. You learn a dictionary: a few hundred atoms, mostly little edges and blobs, and any patch is written as a weighted sum of a handful of them. The dictionary is the basis, the weights are the coefficients, and in this one case the framing of this essay is not a metaphor. It is the data structure.

Now a new kind of patch starts turning up: a repeating texture, a weave, a patch of fur. Your edge atoms can still represent it, but it takes a lot of them with large weights, and it takes them every single time that texture appears. You have two options, and they are the two exits.

Keep the dictionary and pay in coefficients. Every patch of that texture is expensive to describe, and you pay again on the next one.

Or add an atom shaped like the texture. That costs a fixed amount once, since you have to store the atom and a bigger dictionary is a more complex model. After that each patch costs almost nothing: one atom, one weight.

The arithmetic decides. Total cost is the dictionary plus all the codes. Adding an atom raises the first part once and lowers the second part a little on every patch that uses it. So the decision does not turn on how strange the texture is. It turns on how often it comes back. Seen once, it stays a coefficient no matter how odd it looked. Seen ten thousand times, the atom pays for itself.

That is the most useful thing this framing buys, and it is not obvious. A one-off shock, however violent, is psychological. You absorb it as an expensive mix and move on. A modest pattern that keeps recurring is what earns a new generator. Frequency, not drama.

It also says when growing is wrong. Add an atom for every unusual patch and the dictionary swells into a list of everything you have seen, which is just storing the data again.

The third move

There is the operation I promised, and it is the one that makes Hamming's split hardest to hold.

Go back to the dictionary. Keep it exactly the same size, but swap the atoms for better ones. Nothing was added and the space it covers need not change, yet every patch now needs three atoms instead of eleven and the total cost drops sharply. Nothing grew and something real happened.

That is a change of basis, and it is neither exit. Not reweighting, because the generators themselves moved. Not growth, because nothing became reachable that was not reachable before. It is the same space, described better.

The everyday case is the numerals you are reading this in. Multiply MDXLVIII by XXIII, then multiply 1548 by 23. The same numbers were expressible both ways and nothing about arithmetic changed, but positional notation is a coefficient vector: 1548 is the weights 1, 5, 4, 8 against the generators 1000, 100, 10 and 1. Roman numerals are not, which is why IV and VI mean different things from the same two symbols. One honest complication. Positional notation needs a zero to hold an empty place and Roman numerals have none, so the historical shift was a bundle: one new generator, then a rebase the new generator made possible.

I think this is what most people mean by insight. A reframing feels like logical novelty, because the landscape looks different afterwards and you cannot unsee it. But no direction was added, so by the definition I have been using it is psychological. The honest reading is that Hamming's two categories are not quite enough, and rebasing is what they leave out. It is still not a third exit, though. Rebasing sits on another axis: not what to do with the basis you have, but which coordinates you keep everything in.

It does share the economics of the second exit. Europe had Hindu-Arabic numerals from Fibonacci in 1202, kept its accounts in Roman for centuries, and in 1299 Florence's money-changers banned the new ones outright. Changing basis costs relearning, retooling, and translating everything already written, so like a new atom it pays only if you will spend long enough in the new coordinates. A reframing you reach for once is not worth the move.

Whose basis, and Hamming's regress

Now the objection I owe Hamming.

Dictionary learning has "add an atom" built into it. The procedure was written in advance, and so was the range of atoms it can reach. So was the new atom ever really outside the space? Compared with Tuesday's dictionary, yes, since no reweighting produced it. Compared with the range of all dictionaries the algorithm can reach, no. Read that way, growth is only reweighting one level up, and logical novelty disappears. Push it and it never stops: whatever produced your new generator was some capacity you already had, sitting inside some larger space you can name afterwards.

This is Hamming's suspicion at full strength, and the vector picture does not refute it. I do not think anything does. You can always propose a bigger space in hindsight, which makes the absolute question, is logical novelty possible at all, for anyone, probably unanswerable rather than merely unanswered.

What the picture does is make the question answerable by making it relative. Novelty is logical or psychological relative to a named basis. That sounds like a retreat and I think it is the opposite, because what a system actually holds decides what things cost it. A texture that needs a new atom is, for that system with that dictionary, in a different class from one it can already code cheaply, and the difference shows up in bits rather than in intuition.

The relative move rescues the machine and the dictionary cleanly, because there the basis is a named object and the cost comparison is arithmetic you can actually run. For a person it is not. My own point about the asymmetry — that nobody can write down what our basis covers — is exactly what makes the cost comparison uncomputable for us. If I cannot enumerate my generators, I cannot price the choice between squeezing them and adding one; I only ever feel the result. So the relative question does not fully dissolve for people. It splits: answerable in principle, because the accounting is well defined, and intractable in practice, because the ledger is hidden from the thing keeping it. The systems where "look for the two exits" is advice you can follow are the ones that hold their basis as an object — dictionaries, models, codebases. For minds it stays a description of what is happening, not a test you can apply from the inside.

Computation is the one place I know where this bottoms out in something firmer. The computable functions are closed under composition, so you cannot combine computable things and end up outside the set. Whatever a program does, however much it surprises the person who wrote it, was already reachable from the pieces it was built from. That puts a theorem under Hamming's claim about machines rather than a hunch. (The closure is the theorem. Church–Turing, the claim that this covers everything we could mean by computable, is a thesis, because one side of it is an informal idea.)

It also sharpens the asymmetry he was circling. For machines the question is settled his way. For us it stays open, so nobody can show we cannot leave it. That is not evidence that we can.

Last, whose basis I mean, because it changes the mechanism. A person's grows by learning. A field's grows by argument, and by somebody refusing to accept the current framing. A formal system's grows by stipulation. A trained model's grows by optimization, or by an engineer. These are not the same process. What they share is the accounting: a small structure that regenerates, a state that weights it, and a decision about when squeezing the structure costs more than growing it. That is weaker than "it is all one mechanism," and it is the claim I can defend.

What it borrows, and one instance

The storage argument was borrowed, and so is this one. Model-based reinforcement learning is what you get once you have a basis you can plan with. Model-free learning still learns, it just grinds through experience, because it never builds the thing that would let it generalize. None of that follows from basis and coefficient. The picture does not prove it, it borrows it, and what it buys is bookkeeping: a question about two kinds of novelty and a question about compression turn out to be the same account, so results on one side are allowed to constrain talk on the other.

I did not start from the rule and hunt for examples. I got here by studying active inference, and once the two exits were visible the Free Energy Principle looked less like the source of the picture than a clear instance of it: the generative model is the basis, current beliefs are the coefficients, parameter learning is the first exit, structure learning is the second, and variational free energy is the cost — accuracy against complexity, the same trade the dictionary was making. I should name the obvious risk, since a framework you have just learned is the kind of thing you start seeing everywhere, which is dictionary bloat by this essay's own accounting. The test I would want applied to me is the sparse coding one: does it make the description cheaper? I half trust that it does, and the reason is the order I found things in — the two exits were visible in the dictionary before I mapped them onto structure learning.

That is enough to give the distinction a stake. If a system only ever reweights and never grows, everything expensive stays expensive. Every situation the basis cannot cover is solved from scratch, at full price, again and again, each problem arriving disguised as new.

Why it matters

Find a new generator and you have not finished discovering. You have opened a room.

Learn to drive and you have not made one new journey, you have a way of moving. The shop, a friend's house, a road you have never taken: all psychological, new combinations of a skill you are no longer inventing. Hamming's line about mathematics, read the other way round, says the same thing. Given the postulates, everything after is psychologically novel, and that is a large and useful space rather than a consolation prize.

The dictionary sharpens it. A generator is worth its cost in proportion to how often it gets reused, so the rooms worth opening are the ones you will spend a long time inside. That is a warning for anyone who likes the dramatic exit: a framework you invoke once is a bloated dictionary, not a discovery.

Anyone who has looked after a codebase has felt all three moves. A library is a basis and application code is coefficients. Refactoring is the change of basis: nothing new, everything cheaper afterwards. Adding a primitive is growth, and it pays only if it recurs, which is the whole argument against the helper you pulled out for a single call site.

It is also why a small model beats a long list of rules. Expert systems stored answers as rules, and when a case did not match, somebody wrote another rule. That is the expensive path, where every new instance becomes a generator and the dictionary swells exactly as predicted. Modelled inference does the opposite. Keep a small model, treat the situation in front of you as a weighting, and add structure only when no weighting of the old pieces will do. You do not have to stop using rules. You have to stop treating every solution as one.

What's mine, and what isn't

Nothing here is new on its own. The novelty split is Hamming's, algorithmic information theory got to the storage argument first, model-based reinforcement learning's advantage is documented, sparse coding has been adding atoms for decades, and active inference already has names for both exits. What is mine is noticing they are the same account, with Hamming's two kinds of novelty as the thread.

I still cannot tell him whether logical novelty is possible in the absolute sense. I have come to think that question has no answer, and that the relative one is the useful thing he left behind: not "is this new to the universe," but "is this new to the basis you are holding, and what does it cost you to find out."

If you are modelling something that has to live in noisy experience and still keep a cheap set of generators, look for the two exits. Reweighting is the common move. Growth is the rare one. The interesting systems are the ones that can tell the difference.

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

A library is a basis. App code is coefficients. Refactoring is a change of basis. I use compression and sparse coding to pin down what actually counts as a "new idea" — and why frequency, not drama, earns one.

A Psychological State is a Coefficient Vector

A Psychological State is a Coefficient Vector

Hamming's leftover question

New weights versus new directions

Storage, and time

The state is the recipe

Two exits

When an atom pays for itself

The third move

Whose basis, and Hamming's regress

What it borrows, and one instance

Why it matters

What's mine, and what isn't

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