A thought experiment in graph-native machine intelligence.
A Memron is a proposed computational unit where memory and neuron collapse into one construct.
Not a neuron connected to memory.
Not a memory record retrieved by a model.
A Memron is both.
It is a stateful unit of prior experience that activates when new input resonates with what has been experienced before.
Most neural networks treat memory, activation, and connection weights as separate concepts.
A simplified version looks like this:
activation = f(input × weight)
Memron starts from a different assumption:
activation = f(experiential resonance)
In other words, activation is not primarily a product of a fixed edge weight. It is a function of proximity between the current input and previously experienced structures.
That proximity may include:
- conceptual similarity
- temporal nearness
- relational context
- state similarity
- causal adjacency
- contradiction pressure
- recurrence across prior experiences
The core question is not:
How strong is this connection?
The better question is:
To what degree has this kind of thing been experienced before?
A lot of AI systems separate the model from memory.
The model is trained. The memory is retrieved. The context is assembled. The answer is generated.
That works, but it is also strange.
Human intuition does not seem to work like a search engine glued onto a generator. A familiar situation does not merely retrieve a fact. It reactivates a pattern. It carries a sense of similarity, expectation, risk, confidence, contradiction, and next likely movement.
Memron explores whether those ideas can be represented directly as a living graph.
The graph is not just input to a model.
The graph is the model substrate.
Nodes are Memrons. Edges are experienced relationships. Time is part of the structure. Activation is resonance. Learning is consolidation. Inference is propagation through remembered experience.
A Memron graph is intended to be temporal, semantic, and stateful.
It is not a linguistic transformer. It is not an LLM. It is not GraphRAG with different branding.
The goal is to reason over structured experience directly.
A Memron may represent an entity, event, claim, pattern, contradiction, rule, source, or abstraction.
A basic Memron might track:
identity
concept signature
temporal signature
state signature
relational signature
activation
familiarity
novelty
confidence
salience
experience count
first experienced time
last activated time
linked Memrons
The important part is not the exact schema. The important part is that memory and activation live in the same unit.
A link between Memrons is not merely a trained weight.
It is a trace of experienced proximity.
A link may represent:
- co-activation
- temporal sequence
- support
- contradiction
- causality
- dependency
- generalization
- refinement
- exception
- similarity
The strength of a link should emerge from experience:
recurrence
contextual consistency
temporal reliability
causal usefulness
source reliability
decay
contradiction
A link is not important because a training pass made it large.
It is important because the system has repeatedly experienced that proximity as meaningful.
Propagation is not just signal passing.
Propagation is reactivation.
A new experience enters the graph and activates nearby Memrons based on resonance. Those Memrons then recruit other Memrons that have historically been experienced nearby in concept, time, state, or relation.
This should allow the graph to surface:
- familiar patterns
- likely next states
- hidden dependencies
- unresolved contradictions
- novelty
- causal suspicion
- significant events or claims
- stable abstractions
The system should be able to say, in effect:
I have seen this shape before.
That may be the seed of useful machine intuition.
Every input should produce at least two signals:
familiarity = how well the input resonates with prior experience
novelty = how much of the input is not explained by prior experience
Highly familiar inputs should activate stable patterns quickly.
Novel inputs should create provisional structure.
Recurring novel structures should consolidate into stronger Memrons.
Contradictory inputs should create tension rather than quietly overwrite the graph.
Learning in Memron is not only parameter update.
Learning is graph evolution.
Possible learning operations:
- reinforce recurring co-activation
- create new Memrons for unexplained experience
- decay unused or noisy structures
- merge near-duplicate Memrons
- split overloaded Memrons
- add contradiction links
- form abstractions from repeated subgraphs
- strengthen patterns that make useful predictions
The model learns because the graph changes.
The graph changes because experience accumulates.
A minimal experimental architecture might include:
Memron
MemronLink
Experience
ActivationContext
ResonanceFunction
PropagationEngine
ConsolidationEngine
DecayPolicy
ContradictionDetector
NoveltyDetector
Initial Memron types:
Entity
Event
Claim
Pattern
Source
Rule
Contradiction
Abstraction
Initial link types:
similar_to
coactivated_with
precedes
supports
contradicts
causes
depends_on
generalizes
refines
exception_to
The first useful prototype does not need to simulate a brain.
It only needs to prove the substrate.
A reasonable first target:
- Accept a small structured graph of claims, events, entities, sources, and timestamps.
- Convert those structures into Memrons.
- Activate Memrons based on conceptual, temporal, relational, and state proximity.
- Propagate activation through experienced links.
- Identify familiar patterns, novel residue, contradictions, and high-salience subgraphs.
- Consolidate repeated structures into stronger Memrons.
If that works, the next question becomes whether the system can learn domain-specific intuition from repeated exposure.
Memron is not proposed as a replacement for LLMs.
LLMs are extremely good at language. Memron is aimed at something else:
- experience-based reasoning
- temporal pattern recognition
- contradiction awareness
- causality suspicion
- graph-native semantic memory
- domain-specific intuition
Language models may still be useful around the edges. They can help extract candidate structures from text or render graph state back into prose.
But they should not be the center of the system.
Intelligence may not require a clean separation between model and memory.
A useful reasoning system may be built from units that remember, activate, adapt, and propagate based on experienced proximity.
That unit is the Memron.
This repository exists to explore that idea.