Chapter 4 set out to give the system a map. Instead of reconstructing meaning from raw passages at every query, it keeps interpretation: entities, relationships, claims, communities, each traceable back to the artifact it came from. Whether that map pays for itself is Chapter 4’s own question and Chapter 4’s own experiment; nothing here assumes its verdict.

This chapter asks a question that arises either way. Suppose the map exists. A map is a structure to search. Remembering is not a search — or at least, human remembering does not feel like one. Something occurs to you, and something else follows from it, and the thing you needed arrives three steps later by a route you did not plan.

The question is whether that difference is mechanically real, and whether it buys anything:

Once memories have persistent representations and relationships, how should activation move through them so that one memory can evoke another?

The working name for this is associative memory. The chapter’s job is to build it, to compare it fairly against the systems the book already has, and to report what happens even if the answer is that it was not worth the trouble.

A graph is not yet remembering

Here is the shape of the book’s progression so far, and the step this chapter proposes.

Chapter 3
raw history → retrieval → context → answer

Chapter 4
raw history → persistent derived graph → graph-aware retrieval → answer

Chapter 5
query/cue → seed activation → propagate through the graph
          → retrieve associated memories → answer

Chapters 3 and 4 both treat retrieval as a lookup: given a query, find the items most like it. In Chapter 3 the items are passages and the likeness is embedding distance. In Chapter 4 the items are graph elements and the likeness may include a neighbourhood, but the neighbourhood is still selected by a query-to-item comparison. In both, the relationship structure is something the retriever consults.

The alternative is that the structure is something recall travels through. Activation enters the graph at whatever the cue touches, and then moves — attenuating with distance, competing with other branches, stopping when it runs out. What comes back is not the set of nodes nearest the query but the region the cue lit up.

That is a real mechanical difference and it should have measurable consequences. The rest of the chapter is about finding out which ones.

Memories lead to memories

Someone thinks cat.

What follows is not a ranked list of cats. It is a particular cat, then an incident involving that cat, then the house where the incident happened, then a person associated with the house, then something that person once said. By the fourth step the memory has almost nothing to do with cats. It is not similar to the cue. It is reachable from the cue, along a chain in which each link was, at the time, the obvious next thing.

A project history has the same shape. The question

What was behind the budget problem in the migration?

may need an artifact that never mentions the migration, never mentions a budget, and shares no vocabulary with the question — because the route runs through a person, to a project, to a supplier, to an invoice, and the invoice is the answer.

Two things are worth extracting from the intuition before it gets over-used.

The first is that the useful memory can have weak direct similarity to the cue and strong reachability from it. If that is common in real histories, a retriever that only measures similarity has a systematic blind spot that no better embedding fixes, because the property it is missing is not a property of the item at all. It is a property of the path.

The second is that the path depends on the cue and not only on the entity. Consider the same person under different active contexts. In this book’s history, a.silva appears in the event-store migration, in the removal of the legacy corpus_import domain, and in the Strategy X backfill failure that left orphaned rows. Those are three unrelated regions of the project. A query about a.silva and the backend should not activate the same neighbourhood as a query about a.silva and foreign-key checks. The classical statement of this is Tulving and Thomson’s encoding specificity principle: what can be retrieved is determined jointly by what was stored and by the cue present at retrieval, not by the stored trace alone. Recast as engineering, it says the relevant neighbourhood is conditioned by the active cue, and entity identity is not enough to fix it.

Both of these are testable. Neither is established by finding the intuition appealing.

From similarity to pathways

The mechanism has a long history, and the honest version of that history is a warning as much as an invitation.

Collins and Loftus described semantic memory as a network of concepts joined by links of varying strength, in which processing a concept makes it a source of activation that spreads outward in parallel, weakening with distance and with time. Where activation from two sources intersects, relatedness is detected. The theory was explicit that activation must attenuate: without decay the whole network lights up and the signal is gone.

Information retrieval tried this, and its verdict is the useful part. Crestani’s survey reviews two decades of spreading-activation models over semantic networks and analyses critically whether the technique earned a place in associative retrieval. The vocabulary the field settled on is itself the finding: the usable variant is constrained spreading activation, hedged with limits on how far activation may travel, how many neighbours it may reach, which paths are eligible, and how weak it may become before it stops. The technique did not struggle because the idea was wrong. It struggled because an unconstrained mechanism retrieves everything and calls it relevant.

That matters here more than it usually would. The Chapter 3 runs in this book already show the baseline solving nearly the whole fixture on task accuracy while leaving low source precision as a residual weakness. Associative expansion is, structurally, a way of retrieving more. A mechanism that recovers useful indirect memories while tripling the irrelevant ones has not improved this system; it has moved its failure somewhere less visible.

So the chapter’s prediction, registered before the runs, is that the constraints will matter more than the propagation rule. Two independent pieces of prior work point the same way. The MemORAI authors — reporting on a 2026 preprint, so their numbers are author-reported and unrefereed — measure their query-conditioned edge weighting at about two points of turn-level recall@10, their query-focused subgraph scoping at about thirteen, and their topic segmentation at most of the system’s performance. The SYNAPSE authors, in a refereed paper, report that removing lateral inhibition cost about one point of average F1 while removing decay collapsed temporal reasoning and removing the fan term collapsed open-domain performance. In both systems the elaborate mechanism was the cheap contributor and the blunt constraint was the expensive one.

The graph becomes active

The graph this chapter needs is smaller than the one Chapter 4 produces. It needs nodes with descriptions, edges with relation labels, and source provenance on both:

nodes         entities, claims, and the source artifacts themselves
edges         a relation label, a weight, and the artifacts that evidence it
provenance    every node and edge traceable to raw history

Everything else — communities, community reports, claim typing — is Chapter 4’s business, and Chapter 5 consumes the abstraction rather than the package behind it. The adapter takes a structured-memory snapshot and produces a memory graph; if the backend changes, the adapter changes and nothing above it does.

Onto that graph the chapter adds one thing that Chapter 4 does not have: a per-query quantity.

activate the seeded nodes
   ↓
send activation over eligible edges
   ↓
activate neighbours to different degrees
   ↓
propagate again
   ↓
decay, suppress weak paths
   ↓
select a bounded memory subgraph

Activation is never written to the graph. It belongs to this act of remembering and disappears when the query does. The graph records what the project’s history contains; activation records what this cue reached. Keeping those in separate objects is not fastidiousness — it is what makes the same graph answer two different questions differently, and it is what stops one query’s traversal from becoming a fact about the corpus.

The cue has to get in somewhere

Before anything propagates, the cue has to become a set of seeded nodes, and a bad seed poisons every mechanism downstream. This is easy to leave implicit and expensive to get wrong: the HippoRAG 2 authors report that changing seeding alone — from named-entity matching to matching the whole query against extracted triples — moved multi-hop recall by over twelve per cent, which is larger than most differences between propagation methods.

Four seeders are implemented, and they are measured separately from propagation for exactly that reason.

class Seeder(Protocol):
    """Map a cue onto seeded nodes with initial activation."""

    name: str

    def seed(self, cue: str, graph) -> list[Seed]:
        ...

Lexical seeding scores inverse-document-frequency-weighted term overlap, which handles the identifiers a project history is full of — adr-007, incident-026 — better than any embedding. Embedding seeding compares a cue vector against node-description vectors, reusing the Chapter 3 providers so that embedding identity means the same thing in both chapters. Hybrid blends the two. Oracle seeding reads the evaluator’s ledger directly; it is not a deployable system but a diagnostic, because when oracle seeding fixes a case that hybrid seeding fails, the fault was at the entrance to the graph and not on the journey through it.

Two ways to move

Two propagation mechanisms dominate the modern literature, and they are different enough that implementing only one would have decided the question by construction.

Personalized PageRank leaves the graph alone and changes where the random walk restarts. Jeh and Widom’s formulation biases the stationary distribution toward a preference vector; Haveliwala’s topic-sensitive variant had already shown that a global importance measure becomes query-relative by changing the reset distribution rather than the graph. The reset vector is exactly the seed-activation interface this chapter already needs, which is why HippoRAG and HippoRAG 2 both use it: seed from the query, run one pass, read off importance.

Its cost is specific and worth naming. A stationary distribution has no notion of hop count. It can report that a memory is reachable and important; it cannot report that the memory was three steps away, because in the limit every step has already happened. Path length has to be recovered separately, and the value recovered is approximate.

Spreading activation keeps the hop structure. Each step, every active node retains a fraction of its own activation and receives what its neighbours send:

a_i(t+1) = retention · a_i(t)
           + Σ_j  spread · w_ji · a_j(t) / fan(j)

The implementation follows the form SYNAPSE reports, with their published settings as the starting point rather than tuned values: half the activation retained, four-fifths of what is transmitted passed along, and division by the sender’s fan.

for node_id, level in sorted(levels.items()):
    if level < config.activation_threshold:
        continue
    neighbours = graph.neighbours(node_id)
    divisor = fan_divisor(len(neighbours), config.fan_division)
    for neighbour, edge in neighbours:
        weight = self.edge_weight(cue, edge)
        delivered = config.spread_factor * weight * level / divisor
        if delivered < config.activation_threshold:
            continue
        incoming[neighbour] = incoming.get(neighbour, 0.0) + delivered

Termination does not depend on remembering where the walk has been. Activation decays multiplicatively and the threshold cuts it off, so a cycle dies out instead of circulating. The hop and node budgets exist as well, and the tests check that each of the three can be the binding constraint, because a mechanism whose only safety property is a hop limit is a mechanism that has not thought about cycles.

A third strategy is included as the honest floor: bounded-hop neighbourhood expansion, which is roughly what a static graph memory already does. If that matches spreading activation, propagation has bought nothing.

Context changes the path

The fourth strategy is the one the chapter’s central claim depends on. In plain propagation, activation leaves a node the same way whatever the cue was. Cue-conditioned propagation recomputes the edge weight per query from the agreement between the cue and the edge’s own description, so two questions about the same person travel differently. This is the mechanism MemORAI calls dynamic weighted PageRank.

One design decision inside it matters more than it looks. Conditioning attenuates edges; it never removes them. A cue-irrelevant edge is scaled toward a floor rather than severed, because severing would make the graph itself query-dependent — and the whole architecture rests on the graph asserting what the history contains while retrieval expresses what this question prefers. Those must not become the same object.

multiplier = self.floor + (1.0 - self.floor) * min(1.0, overlap * 2.0)
blended = (1.0 - self.strength) * 1.0 + self.strength * multiplier
return edge.association * blended

At strength = 0 this reduces exactly to unconditioned propagation, which is what makes the ablation a one-line change rather than a second implementation.

Association is not truth

This is the chapter’s most important distinction and it costs nothing to get right at the start, so it is worth stating before any results.

There are at least two entirely different things an edge can be carrying. The first is a claim about the world, grounded in evidence:

adr-007         SUPERSEDES      adr-003
evt-205         SUPPORTED_BY    evt-203
event store     CURRENT_BACKEND PostgreSQL

The second is how readily one memory should evoke another during recall:

event store  → evt-205    0.75
evt-205      → evt-203    0.80
evt-203      → session-019 0.70

These are not the same quantity and they must not be summed into one weight. A route can be heavily travelled and lead to something false; a proposition can be certainly true and sit on a route nobody needs. The principle the rest of the book inherits is:

Association strength is retrieval priority, not epistemic confidence.

It follows that a frequently traversed pathway can be useful without making the underlying proposition any more true, and that nothing may raise a claim’s confidence because a route to it was popular. The implementation keeps four quantities in four places and never collapses them:

Query-relative relevance, source authority, and recency are further distinct quantities. They enter later chapters; the point here is that the single-weight temptation is available at every step and is refused at every step.

Follow the pathway

If memory is going to reach an artifact through four hops, the system has to be able to say how. The trace is not decoration; it is the difference between a retrieval you can debug and one you can only accept.

cue: What still had to move before the first release after the event-store migration?
seeds: source:release-024(0.49), source:session-051(0.40),
       source:migration-run-103(0.32), claim:intent-401(0.26)

intent-401 backup obligation --RAISED--> commit-112   (w=0.60, delivered=0.045)
intent-401 backup obligation --ABOUT--> backup configuration   (w=0.70, delivered=0.053)
intent-401 backup obligation --COMPLETED_BY--> commit-118   (w=0.70, delivered=0.053)

A trace answers why did this memory reach my context? That is a different question from why should I believe what it says?, and the book has a name for keeping them apart: retrieval causality. The path is evidence about how retrieval behaved. It is not evidence for the claim at the end of it. Chapter 7 will build the structure that answers the second question; conflating the two here would let a well-travelled route masquerade as support for whatever it leads to, which is precisely the error this chapter’s later sections are about.

The trace renders with that disclaimer attached, because a path is persuasive-looking in a way that invites the confusion.

Build it

The package sits above Chapter 4’s abstraction and beside Chapter 3’s baseline rather than replacing either.

ORIGINAL EVIDENCE
      ↓
Chapter 3 RAG substrate
      ↓
Chapter 4 persistent graph
      ↓
Chapter 5 associative activation
      ↓
selected memory subgraph
      ↓
context
      ↓
reader / action

Fallback runs the other way. When associative retrieval is uncertain, static graph retrieval remains available; when that is uncertain, strong RAG remains available; underneath all of it the raw source artifacts remain authoritative and reachable. No layer here is permitted to become the only way to reach history.

solution/associative_memory/
    config.py              every parameter that defines a run
    pipeline.py            cue in, bounded selection and trace out
    fixtures.py            the deterministic ledger graph and cue set
    experiments.py         E5-A .. E5-H
    cli.py                 fixtures | health | recall | compare | experiments | demo
    graph/adapter.py       MemoryGraph; adapter from a Chapter 4 snapshot
    seeding/               lexical, embedding, hybrid, oracle
    propagation/           direct, pagerank, spreading, conditioned
    activation/            state, decay, fan division, lateral inhibition
    pathways/              traces, versioned weights, Stage-B learning
    evaluation/adapter.py  bridge to the Chapter 2 instrument
    health/checks.py       structural diagnostics

Using it is three calls:

seeds = seeder.seed(cue, graph)
result = retriever.retrieve(cue, graph, seeds)
for memory in result.admitted:
    print(memory.node_id, memory.activation, memory.path)

Before any of this touches an LLM-extracted graph, it runs on a fixture small enough to reason about: a 73-node, 101-edge graph built directly from the project’s canonical running examples, so every node corresponds to an artifact the rest of the book already uses and no identifier is invented. The fixture is deliberately unfriendly. It contains a dominant hub — the event-store decision touches thirteen neighbours against an average degree of 2.8. It contains derived echoes that restate a decision without independently supporting it (runbook-006 echoing adr-007, staging-log-018 echoing incident-026). It contains a same-symptom, different-cause trap (incident-106, a timeout caused by network saturation, sitting next to the nine-minute schema outage). It contains a superseded procedure, weakly connected truths with degree one or two, three actors who each appear in three unrelated regions, and cycles.

Twenty cues probe it, labelled by what they are testing: cases where direct similarity should already succeed, cases where the evidence is two or more edges away, cases where the same entity appears under different active contexts, adversarial cases built around each trap, and one unanswerable case where abstention is correct.

The demonstration runs with no model server, no database, and no network:

cd solution && python -m associative_memory.cli demo

Measure it

Chapter 2 owns scoring, and nothing here reimplements a scorer. An associative retrieval is converted into the instrument’s SystemOutput and handed to score_task exactly as the Chapter 3 baseline is. What the chapter adds is a small set of path-quality observations that only make sense for a system that traverses, kept alongside the instrument’s metrics rather than blended into them:

Path recall — did any activated path reach the required evidence, whether or not it survived selection? Path precision — how much of what propagation touched was relevant? Expansion factor — memories activated per memory admitted. Useful-hop distance — how far the evidence was. Activation concentration — whether recall settled on a coherent region or smeared. Hub capture and distractor rate — whether the loudest or the labelled-wrong memories won.

The most useful of these is the gap between path recall and source recall, because it names which layer failed. High path recall with low source recall is a selection failure: propagation found the evidence and the ranking discarded it. The reverse is a traversal failure. Without the distinction, both read as “the system missed it”.

One constraint is non-negotiable in the comparison. Associative search may explore broadly inside the graph, but what it hands to a reader stays bounded — at most eight memories under every condition, with the exploration cost reported separately. A mechanism cannot win this comparison by injecting more history.

What the fixture runs show

The suite is frozen in experiments/benchmark/runs/ch5-20260919-e5/. Its scope has to be stated plainly before its numbers are read: these are retrieval-level results on a synthetic graph. No reader runs, no answers are generated, and nothing here is a comparison of Chapter 3 against Chapter 4 against Chapter 5 on task accuracy. That comparison needs the other two chapters’ frozen runs and is pending.

Twenty cues, matched context budget, mean over cases:

Four things in that table are worth more than the headline.

The edges carry information. The shuffled-edge control rewires the graph while preserving its degree distribution — a control borrowed from the temporal-shuffle test in recent associative-memory work. Recall falls from 0.875 to 0.675, below even the no-propagation floor. Propagation over a graph whose structure has been destroyed is worse than not propagating at all, which is the result that licenses everything else: the gains are coming from the relationships and not from having touched more nodes.

Propagation’s gain over seeding alone is real but small. Cue-conditioned propagation recovers five points of source recall over the floor. That is the entire headline effect, and it costs about six context tokens per cue.

Precision behaves exactly as the historical warning predicted — except under conditioning. Unconditioned spreading trades eleven points of precision for two and a half points of recall. Plain PageRank loses twenty points of precision and gains nothing. Only cue conditioning gains recall while roughly holding precision, at 0.446 against the floor’s 0.463. The mechanism that makes propagation safe is the one that tells it where not to go.

Direct neighbourhood expansion is the clearest illustration of the failure mode. It has perfect path recall — one-hop expansion reaches everything — and path precision of 0.055, with an expansion factor of 5.9. It finds all the evidence and buries it.

On the eleven cases where evidence is two or more edges away, the picture separates:

Cue-conditioned propagation recovers nine points of recall on the indirect cases at a three-point precision cost, and leaves the easy cases exactly where it found them — identical recall and identical precision to no propagation at all. That last column is the one that would have killed the mechanism had it moved: a multi-hop capability that degrades the cases direct similarity already solves is not an improvement, it is a trade.

Unconditioned spreading and PageRank recover nothing on the indirect cases. Whatever multi-hop capability this fixture has, conditioning is where it comes from.

Why activation must decay

Ablating one constraint at a time gives the clearest result in the chapter.

Removing the activation threshold multiplies the nodes touched by 5.7 and collapses path precision from 0.348 to 0.042 without recovering a single additional piece of evidence. Removing fan division does the same thing less dramatically. Removing decay entirely — no retention, full transmission — costs over a third of recall, because activation that never attenuates never concentrates anywhere, and the selection step has nothing to rank by.

The unconstrained condition is the Crestani warning reproduced on a 73-node graph: 11,509 edge traversals, 8.9 memories activated per memory admitted, path precision of 0.032, and worse recall than the constrained version. Removing every guard does not retrieve more of what was wanted. It retrieves more of everything, and the ranking drowns.

There is also a counter-intuitive result worth reporting rather than smoothing away. Deeper propagation improves precision: at five hops instead of three, precision rises from 0.350 to 0.479 and context tokens fall from 41.0 to 33.5, with recall unchanged. The reason is visible in the traces — with decay applied every step, nodes that stop receiving activation fall below the threshold and drop out, so deep propagation concentrates rather than accumulating. The surviving active set at four hops is smaller than at one. This is the opposite of the intuition that more hops means more noise, it is a property of this fixture at this scale, and whether it survives on a graph two orders of magnitude larger is not something these runs can say.

Why memories compete

Lateral inhibition is the mechanism the chapter expected to matter most and the one the evidence supports least.

Suppressing all but the strongest seven nodes on each frontier changed precision from 0.352 to 0.350 — within noise, and in the wrong direction. It changed nothing on the adversarial subset either: hub capture and distractor rate were identical with inhibition on and off. The same asymmetry appears in the SYNAPSE authors’ own ablations, where removing lateral inhibition cost about one point of average F1 while removing decay cost tens.

The honest reading is that on a graph of this size, the threshold and the fan term have already done the work inhibition was supposed to do. Competition between pathways is real — the fixture is built so that a.silva has four branches competing for one budget — but the competition is resolved by attenuation before any explicit suppression step gets to act.

Fan division, by contrast, earns its place, and the way it earns it is a genuine trade. On the adversarial cases, removing it raises recall to 1.000 and drops precision from 0.517 to 0.410. Dividing a hub’s output by its degree is not free: it makes the loud node quieter, which occasionally silences something that was loud and right.

That trade has a name in the literature. The SYNAPSE authors report a failure they call cognitive tunnelling, where inhibition suppresses a minor but correct detail in favour of a hub. The measurement that would catch it here is hub capture paired with source recall, and it is reported for every condition rather than assumed away.

The cue chooses the branch — but not where expected

The context-conditioning experiment gives a result that complicates the chapter’s own story.

Three cues about a.silva — the event-store proposal, the corpus_import caller migration, the foreign-key failure — each recovered their own branch completely. Recall was 1.000 on every branch cue under every strategy. The cue, not the entity, chose the region. That part of the intuition holds.

But the branch was chosen at seeding, not during propagation. The overlap between the admitted source sets for different cues about the same actor was 0.234 for plain spreading, 0.333 for cue-conditioned propagation, and 0.405 for direct expansion. Conditioning did not separate the branches better than plain propagation did; it separated them slightly worse, because attenuating cue-irrelevant edges keeps activation nearer the seeds and the seeds were already cue-specific.

This lines up with what MemORAI’s ablations reported: their query-focused subgraph scoping was worth roughly seven times what their query-conditioned edge weighting was worth. The finding this chapter can add is a sharper version of the same thing. Where the cue enters the graph matters more than how the cue steers the walk. Conditioning’s contribution shows up in precision on multi-hop cases, not in branch separation — and the intuition about entity-plus-context was right about the phenomenon and wrong about the mechanism that produces it.

When Chapter 4 gets it wrong

Derived structure is fallible structure, and a false relation is not a hypothetical. The false-edge experiment injects the most damaging plausible one: a fabricated SUPPORTED_BY edge wiring the event-store decision hub directly to incident-106, the timeout that looks like the schema outage but was caused by network saturation. It is exactly the mistake an extractor makes when two passages share vocabulary.

In aggregate the effect is small: path precision moves from 0.348 to 0.335. On the cue it was built to derail, it is concrete. Asked what caused the nine-minute outage during a migration, the clean graph admits incident-026, incident-106, and procedure-123. The corrupted graph admits those and adr-007 — the event-store decision, pulled into an answer about an outage it had nothing to do with, by one edge that no source evidences.

Two observations follow. A well-constrained propagation absorbs a single false edge without catastrophe, which is mildly reassuring. And the graph health check flags the edge before any query runs, because it has no source provenance — which is more useful than the absorption, and is the reason the provenance requirement is structural rather than advisory.

Can pathways learn?

Everything above is static. The graph does not change when it is used, and the first result had to be interpretable without learned weights, which is why it is.

The next question is whether experience using memory should change future traversal. A route that repeatedly led somewhere useful might reasonably become easier to travel; a route that led nowhere might fade.

cue → pathway → useful result   → strengthen the route
cue → pathway → irrelevant      → weaken the route
route unused for a long period  → decay toward its base

This is staged deliberately. Stage A asks whether propagation itself helps. Only if it does is Stage B — adaptive pathways — worth pursuing, and Stage B stays behind an explicit flag that is off by default.

The implementation makes one structural commitment before it makes any behavioural one. Adaptive weights are an append-only overlay on an immutable base:

association state = base graph + ordered update log

Nothing mutates the base. Replaying the log reproduces the current weights, truncating the log rolls back to any earlier point, and the question why is this pathway strong? has a literal answer — the list of updates that made it so, each with its reason, its cue, and the outcome it came from. Both properties are asserted in the run record rather than claimed in prose. The alternative, silently mutating weights on a graph that is nominally rebuildable, would make the derived state neither rebuildable nor auditable, which is a worse position than not adapting at all.

On the fixture, three related cues were run in sequence, each judged against the ledger, and the resulting weights re-evaluated on the whole cue set. Ten updates were recorded: nine weakenings and one strengthening. Recall moved from 0.875 to 0.900 and precision from 0.350 to 0.368.

That is a real improvement and a very small one, from almost entirely negative feedback. The single strengthening is worth noticing for a reason that is not about its size: the routes that reached correct evidence were mostly the seeded ones, and a seeded memory has no pathway to credit. There was less to reinforce than the mechanism assumed.

The danger of reinforcing mistakes

The reason Stage B is flagged rather than default is a failure mode that deserves the space.

Suppose a wrong association exists. If retrieval frequency strengthened pathways, then the wrong association would be retrieved, and being retrieved would strengthen it, and being stronger would cause it to be retrieved more:

incorrect association
   → retrieved more often
   → appears useful because it is retrieved
   → strengthened further

This is not speculative. The ACL 2026 study of experience-following behaviour in memory-augmented agents gives the mechanism a name and refereed evidence: agents produce highly similar outputs when a retrieved record’s input is similar to the current one, so inaccuracies in stored experience compound into future behaviour, and previously correct executions can still mislead. A 2026 preprint, MemEvoBench, calls the aggregate phenomenon memory misevolution — behavioural drift from repeated exposure to misleading information — and reports, on its authors’ own unrefereed measurements, substantial safety degradation under biased memory updates with prompt-level defences insufficient.

The experiment makes the loop visible rather than claiming to have solved it. The same corrupted graph, the same cue repeated eight times, two update policies:

cue repeated 8 times: What caused the nine-minute outage during a migration?
the graph carries one fabricated SUPPORTED_BY edge, weight 0.60

  frequency-only   0.65 → 0.70 → 0.75 → 0.80 → 0.85 → 0.90 → 0.95 → 0.95
                   health flags: unprovenanced-edges, frequency-reinforcement
  outcome-gated    0.55 → 0.50 → 0.45 → 0.40 → 0.35 → 0.30 → 0.30 → 0.30

Frequency-driven reinforcement drives a fabricated edge to the ceiling in six rounds. Outcome-gated reinforcement drives it down. The safeguards that produce the difference are four, and each is a refusal rather than a heuristic:

1. Outcomes, not frequency. Only a recorded task outcome moves a weight. Being retrieved moves nothing.
2. Evidence gates. An edge with no source provenance is never strengthened, however well the task went; nor is one whose evidence confidence is below a floor. The fabricated edge fails the first gate and the derived echoes fail the second.
3. Bounds and decay. Weights are clamped and unused routes drift back toward their base.
4. Append-only records. Every change is logged with its reason and can be replayed or rolled back.

And then the result that matters most, which is not the one the safeguards were designed for. Both policies admitted the wrong memory in all eight rounds. The gates stop the weight from running away. They do not remove the false edge, and they do not stop it from putting adr-007 into an answer about an outage. The safeguard addresses the feedback loop, not the fault.

That distinction is the one to carry forward. A memory system that cannot reinforce its mistakes is not thereby a memory system without mistakes.

Co-occurrence is not usefulness

One tempting shortcut is ruled out explicitly. Two memories appearing together often is not a reason to strengthen the route between them.

Frequent co-occurrence can mean duplication, boilerplate, one source quoting another, a popular distractor, or a misconception restated. The fixture contains two instances on purpose. runbook-006 restates adr-007 for operators; staging-log-018 restates incident-026. Both co-occur constantly with what they echo. Neither is independent corroboration of anything, and the ledger records exactly that — their derivation edges point at what they echo.

The evidence-confidence gate is what encodes the refusal: the echo edges carry deliberately low evidence confidence, and the learner refuses to strengthen them even when a route through them produced a good outcome. The test for that refusal is explicit, because it is the kind of property that decays silently.

The general form is that three different relationships hide behind the same statistic:

co-occurrence          two memories appear together
useful transition      one memory usefully leads to the other
independent support    two memories independently evidence a claim

The book’s position is that repetition is not truth, and that a system which strengthens on repetition has confused the first of these with the third.

Did associative memory earn its place?

Four outcomes were registered in advance. The result maps to the first, weakly, with a large piece of the third.

Type A — associative retrieval clearly helps. Partially supported, at a modest size. Cue-conditioned propagation improved source recall from 0.850 to 0.900 overall and from 0.773 to 0.864 on the indirect cases, at a precision cost of roughly three points and about six extra context tokens per cue, without degrading the cases that direct similarity already solved. The shuffled-edge control confirms the gain comes from the graph structure and not from expansion.

Type B — static graph and RAG are already enough. Not supported, but close enough to matter. The no-propagation floor scores 0.850 recall at the best precision of any condition. Everything this chapter builds is competing for five points of recall.

Type C — recall improves, precision worsens. Supported for every mechanism except cue conditioning. Plain spreading activation, Personalized PageRank, and direct neighbourhood expansion all degrade precision, two of them without recovering any recall. The residual precision weakness the Chapter 3 runs already show is made worse by naive propagation, exactly as the historical record predicted.

Type D — adaptive pathways become unstable. Demonstrated under the refused policy and contained under the proposed one. Frequency-driven reinforcement produced a runaway weight on a fabricated edge in six rounds. Outcome-gating with evidence gates reversed it. Neither prevented the wrong memory from being admitted.

So the chapter’s mechanism is earned, conditionally and narrowly. Associative propagation belongs in the architecture as cue-conditioned propagation with an activation threshold, fan division, and a bounded hop count, sitting above the static graph and below the context assembler, with static graph retrieval and strong RAG remaining available beneath it. Lateral inhibition does not earn its place on this evidence and is retained only as an ablatable option. Adaptive pathways do not enter the architecture at all; the mechanism exists, behind a flag, so that Chapter 16 can take up the question with the failure mode already visible.

The fair summary of the numbers is that the constraints mattered more than the propagation rule, which is what the prior work predicted and what this chapter now has its own evidence for.

An analogy, used carefully

The vocabulary in this chapter is borrowed: spreading activation, decay, inhibition, the fan effect, reinforcement. The borrowing is deliberate and it has limits worth stating rather than leaving to inference.

The mechanisms here are inspired by semantic networks, by cue-dependent recall, by hippocampal indexing ideas, and by reinforcement analogies. Each borrowing supplied a hypothesis that turned out to be implementable and testable: decay came from Collins and Loftus and proved essential; division by fan came from Anderson and Reder’s account of the fan effect and proved to be a real precision/recall trade; cue conditioning came from encoding specificity and turned out to be the only mechanism that gained recall without losing precision.

What is not claimed is that any of this is how human memory works, or that the graph is a neural network. Neural networks generally learn distributed weights through optimisation over a loss; this system has explicit memory nodes, interpretable links, and weights that change only through logged, gated, replayable updates. The Hebbian-sounding idea that repeatedly useful co-activation strengthens future access is a statement about routes through an inspectable structure, not a claim of biological equivalence. Where a borrowed term corresponds to a real algorithmic mechanism it is used; where it would only be decoration it is avoided.

The analogy is a source of hypotheses. The evidence is what decides, and in this chapter it decided against one of the borrowed mechanisms.

What prior work contributes

HippoRAG established the design this chapter’s PageRank strategy follows: an open knowledge graph over passages, seeded from the query, ranked by Personalized PageRank in one pass rather than by an iterative retrieve-and-read loop. Its successor, HippoRAG 2, supplied two things the implementation here adopts directly — passage nodes bound to concept nodes, so that a path can always terminate on evidence rather than on derived interpretation, and the finding that seeding method alone moves multi-hop recall substantially. Their honest note that performance on complex associative tasks degrades with corpus growth at a rate similar to plain retrieval is why this chapter measures expansion factor rather than recall alone.

A-MEM is the most useful counter-example in the literature. It builds an associative note graph with LLM-generated links, and then retrieves by embedding similarity over notes: the links change what notes say through a memory-evolution step, and are never traversed. It is a genuine alternative hypothesis — that the value of associations is in re-encoding rather than in propagation — and it is the reason the no-propagation floor is a first-class condition here rather than a formality. Its evolution mechanism, which rewrites the contents of stored notes, is not adopted, because it would break the invariant that raw sources remain authoritative.

SYNAPSE supplied the mechanism inventory: dual-trigger seeding, the fan term, temporal decay, lateral inhibition, a firing threshold, and a hybrid fusion of similarity, activation, and structural importance. It also supplied the ablation design and, in its own numbers, the first hint that inhibition would underperform its billing. Its reported cognitive-tunnelling limitation is what the hub-capture metric exists to detect.

MemORAI supplied cue-conditioned edge weighting and turn-level provenance stored on the edge. Its ablations are the most useful table in the recent literature for this chapter’s purposes, because they measure the propagation refinement against the structural decisions and find the refinement much the smaller term.

MRAgent proposes a third position — a deliberately shallow cue-tag-content structure in which an LLM explores and prunes paths during access rather than arithmetic propagating through them. Think-on-Graph occupies the far end of the same axis, with the model running beam search over the graph. Both are more selective and far more expensive per query than anything implemented here; the chapter tests whether cheap arithmetic propagation suffices before reaching for them.

From the classical side, Collins and Loftus supplied the mechanism and the warning that it must attenuate; Tulving and Thomson supplied the argument that retrieval is a function of trace and cue jointly; Anderson and Reder supplied the fan effect; Crestani’s survey supplied the historical record that unconstrained spreading activation is hard to control. Anderson and Schooler’s rational analysis — that the probability a memory will be needed tracks frequency and recency in the environment — is the strongest classical argument for need-driven access priority, and is deliberately left to Chapter 16, because using retrieval frequency as a proxy for need is exactly the error this chapter’s reinforcement section is about.

The experience-following study and MemEvoBench supply the modern evidence that the reinforcement failure is real rather than theoretical, and the first of them supplies the constructive half as well: future task evaluations can serve as quality labels for stored memory, which is the argument for outcome-gating rather than frequency-gating.

The full matrix, with what was adopted and what was refused for each system, is kept in the project’s research notes rather than reproduced here.

What remains unsolved

The residuals from this chapter are specific enough to hand on.

The comparison that matters has not been run. These are retrieval-level results on a synthetic 73-node graph. The Chapter 3 versus Chapter 4 versus Chapter 5 comparison on answer correctness, under the full instrument with a reader and matched context budgets, requires the other two chapters’ frozen runs. An oracle-path condition belongs in it, to separate remaining traversal failures from reasoning failures.

The fixture is small and hand-built. Every property reported here — including the counter-intuitive finding that deeper propagation improves precision — is a property of this graph at this scale. The adapter that consumes a real Chapter 4 snapshot is implemented and unit-tested against a stub; it has not been run against a real index.

Seeding is doing more of the work than propagation. Branch selection happened at seeding, not during the walk, and the no-propagation floor is within five recall points of the best condition. Whether propagation’s contribution grows or shrinks on a graph two orders of magnitude larger is the first thing a bigger corpus should settle.

Selection and traversal fail separately, and the selection side is untouched. The clearest single failure in the runs is a memory reached at two hops and then ranked out by a hub entity the cue also matched. That is a ranking problem, and Chapters 12 to 14 own ranking, relevance, and assembly.

Cue conditioning is lexically naive. It matches terms between the cue and the edge description, which means a cue saying “move” and an edge saying “moved” do not agree. The gains reported here were obtained despite that, not because of it.

A false edge survives being contained. The safeguards stop reinforcement from amplifying an extraction error; they do not detect or remove it. Distinguishing an extraction error from a retrieval error, and deciding what to do about the former, is not solved here.

Temporal validity has been kept out. Association decay, which is a preference about access, is carefully not the same thing as a claim ceasing to hold. Recent does not mean true, and a stale pathway is not a false one. Chapter 8 takes up validity; Chapter 15 takes up long-term availability.

What remains unsolved. Activation can travel through a memory graph, and travelling through it recovers evidence that similarity alone does not reach — modestly, and only when the cue constrains the route. But the thing the system now returns is a set of memories, each reached by a route, and it still cannot say why any of them should be believed. A path is not a justification. The next chapter takes up what similarity can and cannot tell us about sameness of meaning, and the chapter after it builds the structure that answers why.

References

• A Spreading-Activation Theory of Semantic Processing — Collins and Loftus, Psychological Review 82(6), 1975.
• Encoding Specificity and Retrieval Processes in Episodic Memory — Tulving and Thomson, Psychological Review 80(5), 1973.
• The Fan Effect: New Results and New Theories — Anderson and Reder, Journal of Experimental Psychology: General 128(2), 1999.
• Reflections of the Environment in Memory — Anderson and Schooler, Psychological Science 2(6), 1991.
• Application of Spreading Activation Techniques in Information Retrieval — Crestani, Artificial Intelligence Review 11, 1997.
• Topic-Sensitive PageRank — Haveliwala, WWW 2002.
• Scaling Personalized Web Search — Jeh and Widom, WWW 2003.
• HippoRAG: Neurobiologically Inspired Long-Term Memory for Large Language Models — Gutiérrez et al., NeurIPS 2024.
• From RAG to Memory: Non-Parametric Continual Learning for Large Language Models — Gutiérrez et al., ICML 2025.
• A-MEM: Agentic Memory for LLM Agents — Xu et al., NeurIPS 2025.
• Synapse: Empowering LLM Agents with Episodic-Semantic Memory via Spreading Activation — Jiang et al., Findings of ACL 2026.
• How Memory Management Impacts LLM Agents: An Empirical Study of Experience-Following Behavior — Xiong et al., ACL 2026.
• Think-on-Graph: Deep and Responsible Reasoning of Large Language Model on Knowledge Graph — Sun et al., ICLR 2024.
• MemORAI: Memory Organization and Retrieval via Adaptive Graph Intelligence for LLM Conversational Agents — Van et al., arXiv 2605.01386, 2026 (preprint).
• Memory is Reconstructed, Not Retrieved: Graph Memory for LLM Agents — Ji, Li, and Hooi, arXiv 2606.06036, 2026 (preprint).
• MemEvoBench: Benchmarking Safety Risks from Memory Misevolution in LLM Agents — Xie et al., arXiv 2604.15774, 2026 (preprint).
• Zep: A Temporal Knowledge Graph Architecture for Agent Memory — Rasmussen et al., arXiv 2501.13956, 2025 (vendor-reported).
• Predictive Associative Memory: Retrieval Beyond Similarity Through Temporal Co-occurrence — Dury, arXiv 2602.11322, 2026 (preprint).