The question
Every system that accumulates information eventually faces the same problem: what should it remember, and what should it let go? Keep everything and you drown in stale context. Forget aggressively and you lose the thread that mattered. Most software answers this with hand-tuned heuristics — a time-to-live here, a relevance threshold there — and the thresholds are always wrong somewhere.
OGrE — Opportunistic Graph-enrichment — answers it differently. It treats memory as a dynamical system and hands the final keep-or-evict decision to a chaotic attractor. No magic numbers. Just the geometry.
1Chaos, first: the Lorenz attractor
The demo opens where the idea lives — three short equations:
dx/dt = σ(y − x)
dy/dt = x(ρ − z) − y
dz/dt = xy − βzThat is the entire rule. Yet the solution never settles and never repeats: a single point traces two great wings forever, looping one and then — unpredictably — flipping to the other. This is the Lorenz attractor, the original face of deterministic chaos. Tiny differences in where you start send the trajectory to wildly different places, but it always stays on the butterfly.
OGrE's central trick is to make that structure do work: the left wing means KEEP, the right wing means EVICT. Instead of a threshold you tuned by hand, the deciding vote is cast by which wing a node's trajectory settles into. Chaos becomes the classifier.
2Ingest and enrich
Work items enter the graph through a local Ollama agent (default: qwen2.5-coder:14b, GPU-tiered to fit 12 GB of VRAM). The agent reads each item and extracts its concepts, importance, and dependencies — turning a raw note into a structured node with meaning attached. If Ollama is unreachable, a deterministic heuristic takes over so the simulation always runs.
This is the "opportunistic" part: enrichment happens as items arrive, and the richer the extraction, the better everything downstream behaves.
35D-connascence edges
Enriched nodes don't sit alone. OGrE weaves them together with five-dimensional connascence edges — five distinct kinds of relationship, borrowed from how coupling is reasoned about in software:
In the simulation, edge color encodes the type and thickness encodes the strength. The result is not a flat "related/unrelated" graph but a textured one, where the kind of connection is as legible as the fact of it.
4Decay, propagation, and emergent memory
Every node carries a vitality that decays over time — left alone, anything fades. But vitality also propagates along edges, so connected work reinforces itself. A node that many others lean on keeps getting topped up.
The consequence is the heart of the design: densely re-referenced clusters hold each other up and become stable attractors — the graph's long-term memory, glowing green in the demo. Nobody marks them as important. Importance is an emergent property of the decay-and-propagation field, exactly the way a basin of attraction emerges in a dynamical system rather than being stored in a slot.
5The Lorenz garbage collector
Periodically the garbage collector runs, and this is where the butterfly earns its keep. For each node, OGrE takes its connectivity, connascence, and vitality and uses them as the initial coordinates of a point dropped into the Lorenz system. An RK4 integrator follows that point's trajectory, and OGrE watches which wing it settles into:
- Left wing → KEEP. The node stays in the live graph.
- Right wing → EVICT. The node is pushed out.
- Chaotic boundary → REVIEW. Trajectories near the unstable seam are flagged rather than forced — honest uncertainty instead of a coin flip.
The GC is built on my provenance-engine package. Crucially, load-bearing nodes are spared — if something many others depend on lands in the evict region, it is downgraded to REVIEW rather than removed, so the graph never saws off the branch it is sitting on.
REVIEW is not a verdict — it's a handoff to a human. When the attractor is genuinely undecided, the machine declines to guess and routes the item to a review portal where a person makes the call: confirm it as KEEP, or manually evict it. A human eviction routes through the very same FIFO log as a machine one, so a person's decision stays exactly as resurrectable as the GC's. The geometry decides what it can decide confidently; everything on the seam stays under human control.
6Eviction, forgetting, and resurrection
Evicted nodes don't vanish — they drop into a 100-slot FIFO eviction log. This is short-term, expiring memory: when the log fills, the oldest evictions fall off the tail and are forgotten forever.
But forgetting isn't always final. When an agent searches the past, it walks the live graph first, then the eviction log — and if it finds a referenced item sitting in the log, it resurrects it, pulling it back into the live graph (the blue ring in the demo). Something can fade, get evicted, and still be recalled if it turns out to matter again — as long as it hasn't aged off the tail.
7Tuning the policy: rho and forgetting pressure
The behaviour isn't fixed — it's tuned by the same parameters that shape the attractor. The headline knob is ρ (rho), the chaos dial. Turn it up and the butterfly grows more turbulent, so fewer nodes settle confidently into the KEEP wing — more of them fall back into the chaotic seam and land in REVIEW. So ρ doesn't decide how much you throw away; it decides how hard it is to earn long-term memory. Higher ρ is a stricter bar for confident consolidation.
How much you actually forget is a separate, independent knob: forgetting pressure — the working-set budget. Tighten that budget and the weakest, least-supported nodes immediately spill into the eviction log. In the closing minute of the demo you can watch both: ρ ramps up and the KEEP cluster visibly thins into REVIEW, then the capacity is tightened and the eviction log fills. Tune ρ for confidence; tune capacity to forget more.
8The whole loop
Put together, OGrE is a complete memory lifecycle running on chaos:
ingest → enrich → decay → classify → evict → forget → resurrectA working, inspectable model of memory where importance emerges from structure, forgetting is graceful rather than abrupt, and the keep-or-evict verdict is read off the geometry of a chaotic attractor instead of a number someone guessed. The entire lifecycle renders live and records straight to video — what you watched above is the system explaining itself, frame by frame.