Engram Drift: Why the Way AI Runs Shapes the Way It Thinks


New paper available online - here as a HAL.science paper.

For years, the story we told about AI was simple: a model is its weights.  
Train it, freeze it, deploy it — and the intelligence you get is the intelligence you trained.

But something strange kept happening.

A runtime update would roll out, or the hardware would change, or a new attention kernel would be swapped in, and suddenly the model behaved differently. Not wildly different — but different enough to notice. A little more coherent here, a little more forgetful there. Sometimes better, sometimes worse, but undeniably changed.

Same weights.  
Same architecture.  
Same checkpoint.  
Different behavior.

That’s the moment the old story stopped working.

Engram is the name I give to the layer where this difference comes from — the execution substrate that sits between the trained model and the model we actually experience.

It’s the layer made of:

- precision formats  
- memory hierarchy  
- scheduling decisions  
- kernel implementations  
- hardware topology  
- numerical stability  

These aren’t engineering footnotes. They shape how reasoning survives the physical act of computation.

Think of it this way:

Training defines the ideal model.  
Execution defines the realized model.

And the realized model is the one we interact with every day.

This matters because modern AI systems are no longer simple function evaluators. They’re dynamical processes unfolding over time, sensitive to the substrate that carries them. Small numerical differences accumulate. Memory pressure changes what the model can recall. Kernel fusion changes the order in which information flows. Hardware topology changes the shape of attention.

These aren’t bugs — they’re properties of physical computation.

Engram is a framework for understanding this layer. It explains why inference isn’t perfectly reproducible across hardware, why long‑context models degrade in ways that can’t be explained by weights alone, and why two “identical” deployments can behave differently.

It also opens a new scientific frontier: execution fidelity — the study of how faithfully a trained model is realized during inference.

As models grow more stateful, and hardware grows more heterogeneous, this layer becomes impossible to ignore. Engram gives us the vocabulary to talk about it, measure it, and eventually design runtimes that optimize not just for speed, but for stability and coherence.

The core idea is simple:

AI doesn’t just think because of its weights.  
It thinks through its execution.

And if we want to understand, trust, or improve these systems, we need to study the layer where thinking becomes physical.

That layer is Engram.

Popular posts from this blog

The Second Silicon Winter Is Coming

Silicon Winter: The Final Chapter

MANAGEMENT SPEECH 101: RADEON EDITION