Activation in Practice

What We Are Building

We need it to draw a blank sometimes.

An ordinary search takes your question, finds the handful of things that look most similar, and hands them over. It has no idea how often you have used any of them, when you last did, or what else is currently on the table.

It also cannot refuse. Ask for five results and you get five - and if nothing suitable exists, you get the five least-terrible things, presented with exactly the same confidence as five perfect ones.

Ask five friends about a town none of them has visited

Run it in your head. You ask for the best restaurant in a town none of them has been to. Four say "no idea." The fifth names five restaurants, in order, with total conviction.

You trust the four. A search index is the fifth friend, every time. Back in part one, three Tuesdays ago came back empty, and that empty hand is the behaviour we are trying to build.

Anything that cannot say "I don't know" will make something up instead.

That is why the bar from part three exists. A memory that can return nothing is strictly more useful than one that always returns something, because the empty hand is real information and the least-terrible five are not.

So we took the equations from the first four parts and built the scorer.

What is running, and what is not

The scorer exists, is unit-tested, and has been fitted against real embeddings. Nothing calls it. There is no retrieval path joining candidate generation, graph expansion and event windows into one scoring pass, so the activation model is not reachable from the running system.

Every number on this page comes from an offline harness that touches none of the four stores. It can test the arithmetic, and it found four genuine defects in it. It cannot tell you what Continuum retrieves, because Continuum does not retrieve this way yet.

Fine Print

Every constant in here is a decision somebody had to defend.

Some come from forty years of reaction-time studies, some we measured ourselves, and two are guesses.

Dial	In plain words	Ours
d	How fast the bells fade	0.5
β	The floor of the pool. How deep a memory can sink	0.002
S_max	How loudly one cue can shout across the crowded room	4.0
fan	How many things that cue is shouting at	measured
γ	How much quieter it gets one step further out	0.5
W	How the one spotlight gets divided up	60:40
τ	The bar. Below this, nothing comes back	-4.0
ceiling	How close to the surface a claim can float, given who said it	per claim
ε	The dice roll from part one. Random wobble	off

The floor, and why it is not optional

Back in the pool from part one, picture it with no bottom. The bells from part two fade forever, so an unused memory keeps sinking forever, a little slower each year and never stopping.

Now picture your arm, which reaches down as far as the bar from part three. The loudest any cue can shout is fixed, so the most a shout can lift a memory towards your hand is fixed too. A memory that has sunk far enough drifts beyond that lift and keeps going. It has not been deleted; it is just permanently unreachable, which in practice is the same thing wearing a better coat. We call that a trapdoor.

So we put a floor in the pool. Memories sink towards it and then stop, resting on the bottom, still within reach of anything that shouts loudly enough. In bell terms the floor is about as loud as one bell rung roughly three days ago: faint, and never fainter.

The floor sits below the bar, and the gap between them is 2.21. That is how far a never-before-used memory lying on the bottom has to be lifted by context alone to be worth returning. One really good cue lifts it about four, so a single strong hint gets it over the bar comfortably.

A brand-new memory nobody has ever used is still reachable on day one, because the arithmetic makes it impossible to be otherwise.

The ceiling, which is a cap and never a weight

Everybody wants a way to say "this source is more trustworthy." The usual approach is to add a few points for good provenance.

In the pool, adding points means tying a float to every memory from a good source. That fails arithmetically: anything you add can be out-added. A guess somebody typed once, retrieved often enough, collects enough bells to rise past the float on a carefully sourced constraint.

So instead of a float, we stretch a net across the pool. Who said it decides how deep the net hangs, which is how close to the surface this can possibly rise. The net stops things rising. It never pushes anything down, so a weak source cannot shove something below the bar that would otherwise have cleared it.

As far as we can find, nobody else combines a cap like this with an activation score, and we cannot yet tell whether that is a contribution or a mistake. Every document in the test corpus is human-authored and grounded, so every entry sits under the same net and switching the cap off changes nothing. So far it is untested.

The hop decay, which we cannot actually justify

From part four: ACT-R spreads one step, Soar spreads many. We spread many, fading by half at each hop.

Which means our halving has no pedigree. We cannot point at forty years of reaction-time studies and say "0.5, and here is why." We picked it. It is a Soar-shaped dial in an ACT-R-shaped machine, and it has to be earned from scratch with our own measurements.

Worse, the "one cue can shout at volume 4" setting was calibrated for one-step spreading. We raised the volume and let it travel further, which is two changes pushing the same direction. Those need untangling.

The other dial we are guessing at

The single spotlight from part three has to light two parts of the stage. One is what the words mean: the question sounds like this passage. The other is what the document structure says is related: this passage sits under the same heading. We point 60% of the light at the first and 40% at the second.

There is no reason for that. It was not fitted, derived or borrowed from anybody; it is a number that felt about right. With the hop decay, it is one of the two unfitted constants in the machine, and both are on the list.

Trial And Error

Fitting the model is where the design actually gets decided.

You cannot reason your way to these constants. The equations tell you the shape of the function; the data tells you where to put it. So you build the measuring equipment, run the thing, and read what comes back - and most of what comes back is about the measuring equipment.

Each of the results below changed the design, and each would turn up in any system of this kind.

A parameter can be live in the code and dead in the data

The floor is meant to sit underneath the quietest memory. Measured against real documents, ours sat above the loudest one - so every memory was resting on it, and the entire history mechanism was contributing nothing: it was inert in forty-two of forty-two swept configurations.

In the pool, that is every object lying on the bottom. How far each one had sunk was the information the history mechanism existed to provide, and we had built the floor so high that nothing had room to sink.

Output looked normal throughout, because a disabled term raises no error and simply stops participating. The check that catches it is looking at the spread of your scores rather than the ranking they produce - if a term is working, removing it should move the distribution.

Optimising for recall deletes the threshold

Recall is the share of answerable questions where the right document came back. It has a property that makes it useless as a sole objective: you can always get more of it by lowering the bar. Fit against it and the optimiser walks the threshold down until nothing is ever excluded, improving the headline number at every step while removing the mechanism that distinguishes recall from search.

Picture the bouncer from part three, paid only for every invited guest who gets in. The best-paid bouncer props the door open and goes home.

The objective has to score correct silence alongside correct retrieval, so that "return everything" stops being a winning strategy. The same principle applies to any metric that is monotone in the thing you are trying to tune.

An evaluation corpus drifts toward its own subject

We test retrieval by asking questions and checking which documents come back. Over a working session, documents describing the harness itself ended up inside the corpus being searched - so the system was being scored on retrieving its own answer key. Picture an open-book exam where somebody has left the marking scheme on the shelf with the textbooks.

An exclusion list cannot fix this, and the reason is structural: the contaminating document is always written after the list. The guard has to be a rule the run enforces on itself - ours refuses to start if any corpus section mentions an arm or probe identifier. It caught a fresh case within a day, which is roughly the rate you should expect.

Instrument the harness as well as the model

Thirty-nine per cent of citations pointed at documents that did not exist. That is the shape of a serious retrieval defect, and it was investigated as one.

The cause was an example in the instructions - a sample citation referencing item 39, which the model reproduced faithfully. Correcting the sentence took the rate to zero. A number that looks like a model failure is frequently a measurement failure, and the measuring equipment is the part nobody instruments.

A summary is not a citation

Four of the primary sources had been worked from search summaries rather than the papers. Reading them properly overturned five claims, three about our own design.

The multi-hop spreading is Soar's mechanism, not ACT-R's - so its constant has no lineage to inherit and has to be fitted here. A deviation we had documented and justified turned out to be ACT-R's default behaviour. Four values recorded as architecture defaults were one teaching model's settings.

The tail is the long run of old, faint bells, and the shortcut estimates their combined volume instead of listening to each one. Described as conservative, it in fact overestimates, by more than double for old dormant entries - which is exactly the population sitting nearest the threshold, where the error decides the outcome.

None of those are visible from a citing paper, only from the manual.

Findings not yet in the specification

The default-behaviour correction and the tail correction are recorded in the research notes and have not yet reached the specification, which still states both of the superseded versions.

Get Rich Or Die Trying

Reinforcing on retrieval made the scorer worse.

The bells from part two only ring when a memory is used, so something has to decide what counts as a use. ACT-R calls the resulting loudness the base level. The obvious candidate for the signal is retrieval itself - the system returned this entry, so ring the bell.

We built that, and it worked exactly as specified. Then we measured it against an arm with reinforcement switched off, and the version with no reinforcement matched or beat it on every metric.

The reason is a loop. Being returned is not evidence of being useful; it is not even evidence of being read. So the signal was rewarding entries for having been chosen by the thing doing the choosing:

It surfaces because it is strong, and it gets stronger because it surfaced.

Think of a radio station that builds each week's playlist from last week's most-played songs, counting its own plays. Each week sounds reasonable, and after a year it plays eleven songs. This is the runaway loop from part four, and we built it ourselves.

So the loop came back out, and the signal moved to the model actually citing an entry in its answer: the bell rings when a memory gets quoted, and stays silent when it is merely handed over. A mechanism that is correct in specification, correct in implementation and wrong in effect cannot be found by reading the code, which is why the harness exists. The related guardrail from part four - holding down recently-used entries - is still missing, and is now near the top of the list.

The Scoreboard

The harness runs offline, against none of the four stores.

Everything below comes from an offline harness that runs ActivationCalculator over Continuum's own documentation - real embeddings, real document ages taken from 208 days of git history, a real model answering and a second one grading. It is the production scoring class, unmodified.

It touches no database: not Postgres, the vector store, the graph or the event ledger. Candidate generation is an exhaustive scan over an in-memory array where production would use an approximate index, which makes every recall figure here an upper bound on the same scorer running against the real thing.

So these are measurements of the equation alone, over thirteen answerable probes and ten unanswerable ones, where a single probe moves a number by eight points.

Reading the table as a night at the door

Put the bouncer from part three on the door. Thirteen invited guests arrive, one per answerable question. Ten gatecrashers arrive, one per question with no answer in the corpus.

Found it is how many guests got in. Correctly said "I don't know" is how many gatecrashers were stopped. Wrongly refused is how many guests were turned away. Plain top-k - take the few most similar passages, which is what ordinary search does - has no door at all.

Arm	Found it	Correctly said "I don't know"	Wrongly refused	Tokens
plain top-k	62%	0%	0%	1702
this scoring, no threshold	69%	0%	0%	1849
this scoring, with threshold	38%	80%	31%	704
— no reinforcement	38%	90%	31%	677
— no spreading	0%	100%	100%	0

The ranking beats cosine. Cosine is the standard "how alike are these two things" score from part two. Same candidates, same questions, scoring swapped: 69% against 62%. That is the row to look at, because it isolates the scorer from the threshold.

The threshold costs 31 points of recall (69% down to 38%) and buys 80% correct refusal. Plain top-k makes something up on all ten unanswerable questions, because it has no way not to - every gatecrasher walks in. With the bar, eight of the ten are stopped. Whether that trade is worth paying is a product decision, and now a measured one. The bill is 31% false refusal - four of thirteen invited guests turned away at the door.

Token efficiency is the clean win. Tokens are the text handed to the answering model, roughly three-quarters of a word each. 704 for the thresholded row against 1702 for plain top-k: 2.4× less context, and 0.55 recall per thousand tokens against 0.36.

One caution about the second row. Spreading is doing nearly all the work - switch it off and recall goes to zero, because without the shout from part three nothing in the pool rises as far as the bar and every question gets the empty hand. Spreading here means heading proximity in a markdown outline, since there is no graph in the harness. Calibrated cosine, a document-age prior and outline locality are all real improvements over naive search. None of them are distinctively ACT-R.

Base level and the ceiling, as measured

Base level is mildly harmful. Switching reinforcement off holds recall at 38% and improves both ranking quality and correct refusal, at fewer tokens. Three fitting passes narrowed this from "inert in 42 of 42 configurations" to "marginally negative", but the term has not earned its place. The harness gives every entry one synthetic use event at its authored date, so what is being measured is document age, not a use curve. Each document rang exactly one bell, on the day it was written, and the room has been quiet since.

The authority ceiling is inert. Every document in the corpus is human-authored and grounded, so every entry lands in the same band and there is nothing for the cap to respond to.

Public memory benchmarks are too short to test this

On the standard industry test for long-term memory, just stuffing everything into the prompt scores 89.0. An elaborate memory system scores 90.6. The memory layer's advantage is almost entirely cost.

And those tests never run long enough to matter. They do not cover hundreds of sessions, and they do not cover what happens when two stored facts contradict each other a month apart, which are exactly the two situations this entire design exists for. Fading only matters over long horizons: a short test sits in the first stretch of part two's graph, where the cliff and the beach still look identical. Supersession - a newer fact replacing an older one - only matters when things conflict. The public benchmarks are structurally incapable of measuring the thing we are building, so the measuring equipment is part of the job.

Where This Is Heading

The roadmap starts with recording real use.

1 Something has to actually ring the bells

We built the ledger that records every use of every memory - schema, storage, tests against a live database, the lot. Nothing writes to it yet. We have a finished bell tower with nobody pulling the ropes.

Which means every fading calculation on this page is currently running on invented history. Until a real producer starts recording real uses, none of the decay numbers mean anything, and we would rather say that plainly than quote them as though they do.

2 Decide what to do about the bar

The ranking measures well and the bar does not. Handed the full list, the answering model decides whether to answer better on its own than our threshold decides for it.

That directly contradicts the headline claim of our own design - the whole "absent, not ranked low" argument. It rests on a small number of test questions, so it is a next experiment rather than a verdict. But it is the most likely thing on this page to be wrong in six months, and it might be wrong in our favour or very much not.

3 Hold down what was just used

The fingers-of-instantiation guardrail from part four. Both architectures have it. We have none of it, and we also reinforce on use, which is the exact combination that produces a system slowly repeating itself.

It is cheap to add - keep a finger on each of the last handful of things returned in this conversation and quieten them slightly. It needs no schema change and is directly measurable, and it is the fix for the radio station above.

4 Prove the whole thing is worth it

The end goal is unglamorous and specific: answer a real question with assembled context, answer the same question with none, and show the difference is real, traceable, and attributable to something other than luck. Everything above is scaffolding for that one comparison.

Arguments we have not settled

Which clock?

We fade against wall-clock seconds. Fading against conversational turns is arguably better for an assistant - an hour of silence is not the same as an hour of talking. Try it on yourself: a detail from last night's conversation, after eight hours of sleep, against the same detail after eight hours of meetings. This was never decided. Seconds were just the obvious thing to reach for.

Cliff or beach?

From part two: the power law is a long beach, the exponential a cliff. We have the argument for the beach and the flashcard evidence backing it. We have not actually run our own version against the cliff with everything else held steady. It is the single highest-value experiment available to us and it is still sitting on the list.

Should a disagreement rise or sink?

When two stored claims contradict each other, should that make them more visible or less? There are arguments both ways, and we lean towards more, because hiding a live disagreement is precisely the failure the rules exist to prevent.

Who can touch the dials?

This is part four's wall, the difference between building a credit history and announcing one. We are on the safe side of it by accident rather than decision, and our tool surface is one careless afternoon away from the other side. Writing "look, never touch" down as an actual rule has not been done yet.

We went looking for other people doing this and found exactly one public implementation of activation as machine memory - and its documentation does not state the formula. There is no implementation at all in our language. Nobody has published one of these with a proper ablation study; the engineering write-ups pick constants and ship.

The science has been sitting there for forty years, almost entirely unused by the people building AI memory. That also means there is nobody to check our homework.

The rules this has to obey

The laws of the context store →

Where this is being built

Milestone 2 →