u/Salt_Diamond5703

Most “AI memory” systems I see start from language: -

chat history, summaries, embeddings, vector search, longer context windows.

But I’m wondering if that is the wrong starting point.

In biological systems, memory does not begin as language.

It begins as events:

something happened, it repeated, it caused something, it mattered, it changed future behavior. So I’ve been testing a different direction:

AI/machine memory as event primitives first, language second.

The primitives I’m testing are:

- consolidation: which events belong together?

- temporal association: what usually happens after what?

- simplicity selection: what is the simplest valid explanation?

- bounded curiosity: what patterns should be tested later?

- embodied feedback: did memory improve future action?

I have released two small C++ demos so far:

Layer 1:

noisy events -> evidence-backed groups

https://github.com/Antriksh005/CONSOLIDATION_CORE

Layer 2:

timestamped events -> repeated event paths

https://github.com/Antriksh005/TEMPORAL_ASSOCIATION_CORE

No LLM, no cloud API, no vector DB in these layers.

My question: If memory starts from events instead of language, what is the most important next primitive?

Surprise?

Valence?

Forgetting?

Contradiction detection?

Action feedback?

So the Layer 1( Consolidation) was about grouping repeated noisy events (which events belong together?).

Now the Layer 2 is about time (what usually happens after what?).

The demo takes timestamped logs and finds repeated event paths like:

db_pool_exhaustion -> retry_storm -> checkout_failure

Current demo result:

- 1000 timestamped log lines

- 13 event families

- 6 repeated A -> B transitions

- 3 repeated A -> B -> C paths

- main path appeared 100 times

- about 6.5 MB peak working set on my Windows run

- no LLM

- no cloud API

- no database

- no vector search

Also the report does not only show numbers. It also shows the actual event families, recovered paths, transitions, and timestamp evidence.

It is repeated temporal association: A repeatedly appears before B inside a time window.

Also one important things, i'm using logs because they're easy to generate, inspect and verify but the mechanism is not limited to logs.

Any timestamped event stream can be tested this way:

sensor readings,

robot actions,

security alerts,

user behavior events,

system telemetry,

financial transactions,

or simulation states.

The core question is just:

given repeated events over time, can the system recover stable paths from them?

Github Repo : https://github.com/Antriksh005/TEMPORAL_ASSOCIATION_CORE

Also let me know if there's any kind of issue regarding the mechanism or implementation details .

I’m building Crystal: a local deterministic memory substrate for machines by biological memory primitives.

Instead of starting with language generation, I’m starting with memory primitives:

consolidation, temporal association, simplicity selection, bounded curiosity, and embodied feedback.

I’m releasing the work layer by layer so each claim can be tested.

​

Instead of relying only on context windows or raw logs, CRYSTAL continuously:

- consolidates semantically similar events,

- builds temporal memory structures,

- and prunes stale information for scalable long-term operation.

Current prototype benchmarks:

- ~5000:1 semantic event consolidation on noisy event streams

- long-running temporal retrieval stability

- adaptive memory pruning for scalable runtime operation

- fully local/offline execution

Currently testing with:

- simulation environments

- agent workflows

- robotics/event streams

- sensor-based temporal patterns

The first public demo build will be opened next week.

Initial focus is not chatbots — but persistent runtime memory for embodied and long-running AI systems.