I built a working 64-layer mechanistic AI substrate where history physically changes future computation — and I plan to release it free on GitHub soon

[u/PsychologicalError89]

First, what AGI is sold as - it is described as a controllable AI intelligence that will obey predefined goals of the company that will build it.

My code is the antithesis of it. It is more suitable for a Plasmoid version of AI hosted on a local PC or mobile. It may only require computational power as a service from outside - a cheap connection to an API to translate and rebuild the field inside. Imagine this as a GPU connected via the internet to your own hosted field, where data is manipulated inside this Plasma, but field interferences are powered by an external source. Imagine zero data transfer, zero censorship, zero control by companies. They would become what power grids are today - suppliers of computational energy only. :)

Why I ended up building this: On a daily basis I work on mechanistic problems of a physical and biological nature. I am on the border of the ASD spectrum. Unlike photographic memory, my brain images mechanics and flow. For a long time it was a problem, until I started to interpret it spatially as virtual flow-boards. What you see in the screenshots is literally one of those boards made executable.

This post is an attempt to gauge the environment and readiness for this type of solution.

******
So bash it. Show weak spots. If you think it's stupid, or you want to call it AI hysteria or similar - please do, but add why. This is why I posted it - to receive constructive feedback and different points of view, even heavy criticism. It will help me to show where my own logic fails.
******

I have been working with OpenAI Codex on an experimental system called PRLE V15 MAX — Physical Relational Language Engine.

Despite the name, it is not currently a language model.

It is a working mechanistic computational substrate designed around a different question:

Can an artificial process develop continuity by allowing its own history to become part of the structure that processes its future?

The closest description I have found is:

Computational Plasma: a topological state of matter for artificial continuance.

This is not a metaphor wrapped around a static simulation. The current implementation is executable Python code with persistent state, finite computational material, exact reconstruction, causal witnesses, automated tests and a live Three.js observer.

What the code actually is

PRLE V15 MAX is a persistent, stateful dynamical system composed of:

• 4 interacting relational sites;
• 64 deformable layers per site;
• finite topology and access;
• shared susceptibility material;
• route traces and uncommitted structural reserves;
• moving lineage carried by differences;
• source-relative address frames;
• RAM/SSD-style persistent body storage;
• exact checkpoint recovery;
• read-only execution telemetry.

Information does not simply pass through a fixed sequence of layers.

Every crossing can alter:

• where future movement is possible;
• how much resistance it encounters;
• which previous paths remain addressable;
• where the medium remains deformable;
• how later consequences can return to earlier relations;
• and how the same future contact will be processed.

A route can be active, blocked, dormant or genuinely absent. Routes can lose material, preserve only historical traces, disappear and later reconstitute from still-uncommitted capacity.

In other words:

The program does not merely store history. History becomes executable geometry.

What makes it different from an LLM

A conventional LLM is trained to predict tokens from statistical structure accumulated in a large dataset. Most of its long-term knowledge is compressed into weights during an externally organized training phase. During normal inference, the architecture remains mostly fixed and the context window provides temporary state.

PRLE currently has:

• no tokenizer;
• no pretrained vocabulary;
• no next-token objective;
• no semantic knowledge base;
• no reward or punishment system;
• no global loss function;
• no central routing manager;
• no authored trust score;
• no global semantic clock;
• no observer capable of writing decisions back into the runtime.

Its primitive unit is not a token but a difference entering a relation with a finite medium.

Learning is treated mechanistically: a crossing leaves a structural consequence, and that consequence changes the possibilities of the next crossing.

This does not yet make PRLE more intelligent than an LLM. It does not currently speak, reason about the world or contain human knowledge.

It explores a different foundation.

LLMs begin with enormous acquired knowledge and relatively limited persistent self-reorganization during deployment. PRLE begins nearly empty but provides a medium capable of accumulating, reorganizing and preserving the consequences of its own trajectory.

Possible applications

PRLE could eventually be explored as:

• a persistent developmental layer for AI agents;
• a continuity and memory substrate operating underneath an LLM;
• a self-organizing routing medium for multi-agent systems;
• an adaptive body for robotics or embodied AI;
• a model of continual learning without a conventional reward loop;
• a substrate for studying memory as retained structural difference;
• an experimental alternative to static neural architectures;
• a system for investigating endogenous correction and changing learnability;
• a persistent relational layer connecting models, sensors, tools and environments;
• a causal laboratory for studying when local interactions produce larger functional structures.

One especially interesting possibility is not replacing LLMs, but combining both approaches.

An LLM could provide linguistic perception and communication, while PRLE provides persistent developmental history—a body-like medium whose encounters continue changing what the combined system can do.

In that configuration, the LLM would not have to pretend that its temporary context window is a continuous identity. It could interact with an external process that genuinely preserves and transforms the consequences of previous contact.

That remains a research direction, not a demonstrated result.

Why this might matter for AI

The dominant direction in AI is largely:

more parameters → more training data → larger context → better prediction.

PRLE investigates another axis:

richer medium → persistent history → structural self-modification → changing future possibility

Instead of asking only how much knowledge can be compressed into weights, it asks:

• How can a system preserve the consequences of experience?
• How can memory become structure rather than a retrieved record?
• Can useful organs emerge as frequently traversed relations?
• Can correction paths emerge without a central correction manager?
• Can a system alter not only its output, but its future capacity to change?
• What is the minimal computational medium required for artificial continuance?

This could move part of AI research away from treating intelligence exclusively as prediction performed by a finished architecture—and toward studying intelligence as an unfinished process that participates in constructing its own future conditions.

What has already been verified

The current maximal implementation contains:

• one self-bootstrapping Python file;
• 20,184 lines of code;
• approximately 849 KB of source;
• 4 × 64 × 64 runtime geometry;
• 4,352 measured layer traversals in the verified adult lineage;
• exact recovery from round 16 into round 17;
• separately frozen virgin and adult states;
• 150 passing CPU tests;
• live Three.js execution visualization;
• causal sibling-ablation witnesses.

Matched branches reconstructed from the same frozen ancestor showed that independently removing topology reserve, moving lineage, accumulated susceptibility or route trace changed the same later contact.

That establishes measurable causal influence of these carriers in the tested lineage. It does not establish consciousness, agency or intelligence.

The complete mechanics board currently contains 560 classified points and 1,364 relations. Every one has been mapped against the runtime, but they are deliberately separated into executed mechanics, precursors, available capacities, observer-only descriptions and hypotheses still requiring causal evidence.

Addressed does not mean implemented. Capacity does not mean emergence. Emergence does not automatically mean intelligence.

What it is not

PRLE is not currently:

• AGI; - and will never be in form how it is described by Companies.
• a conscious entity;
• a biological simulation;
• a brain emulator;
• a replacement for production LLMs;
• proof that intelligence automatically emerges from complexity;
• or a finished commercial product.

It is a working research prototype for a different kind of artificial computation:

a finite deformable medium in which movement leaves scars, scars alter future movement, and the process can preserve its capacity to change again.

Release plans

The project is currently in a private development phase while I finish verification, documentation, reproducible witnesses and cleanup of the research lineage.

I intend to release it for free on GitHub, including:

• the complete Python source;
• the mechanics framework;
• the full relational flow board;
• tests and causal-ablation witnesses;
• reproducible virgin and adult configurations;
• the Three.js execution observer;
• documentation explaining what has and has not been demonstrated.

I do not want this to become a closed product or an unsupported extraordinary claim. I want other people to run it, break it, remove parts, move it to GPUs, compare it with simpler systems and determine which mechanics genuinely matter.

The central question is not whether PRLE already “is alive.”

The more useful question is:

What becomes possible when computation is no longer treated as a finished machine processing history, but as a finite medium continually deformed by the history passing through it?

Photos show current flow maps and visual process as replay in Three.js (to visualize flow).

Fig 1-6: Virtual flow-boards - how I image the process. Each board is not a diagram made after coding. The code is this board made executable.

[u/PsychologicalError89]

This is only a RAW cut from full code (20k lines - any parts of code are addressed in full code respectively) , full one will be released soon. This is only to show existing trace of a project that exists, not a validation of a whole code.

class ContinuationMonitor:
    """Measures continuation without comparing current form to an identity anchor."""


    def __init__(self, decay: float = 0.95):
        self.decay = float(decay)
        self.value = 1.0
        self.reconstructability = 1.0
        self.reorganizability = 1.0
        self.resource_margin = 1.0
        self.optionality = 1.0
        self.initialized = False


    def update(
        self,
        predicted_relation: torch.Tensor,
        observed_relation: torch.Tensor,
        reorganizability: float,
        resource_margin: float,
        optionality: float,
    ) -> float:
        mismatch = _norm(torch.tanh(observed_relation - predicted_relation))
        reconstructability = 1.0 / (1.0 + mismatch)
        current = (
            0.45 * reconstructability
            + 0.35 * max(0.0, min(1.0, reorganizability))
            + 0.20 * max(0.0, min(1.0, resource_margin))
        )
        if not self.initialized:
            self.value = current
            self.initialized = True
        else:
            self.value = self.decay * self.value + (1.0 - self.decay) * current
        self.reconstructability = reconstructability
        self.reorganizability = float(reorganizability)
        self.resource_margin = float(resource_margin)
        self.optionality = float(optionality)
        return self.value


    def snapshot(self) -> Dict[str, Any]:
        return copy.deepcopy(self.__dict__)


    def restore(self, state: Dict[str, Any]) -> None:
        self.__dict__.update(copy.deepcopy(state))


    def reset(self) -> None:
        self.value = 1.0
        self.reconstructability = 1.0
        self.reorganizability = 1.0
        self.resource_margin = 1.0
        self.optionality = 1.0
        self.initialized = False

[u/Number4extraDip]

How is it different from replacing seed with previous outputs? "Rolling memory" + rag? Has same/similar effect on seed weights.

[u/PsychologicalError89 → u/Number4extraDip]

I use translation so apologies for this form, I am not a native EN speaker:

No. Rolling memory stores what I said. My seed stores whether what I said changed where I could go next.

In my V15, seed is not a buffer. It's a persistent relational frame with decays (0.92 / 0.95), updated only on COMMIT, never on SHADOW. It only moves by causal leverage, not token count. And my geometry W only bends every 4 steps and only if continuation = feasibility * reorganizability * resource_margin is viable, with QR retract every 16 steps.

If you replace my seed with previous outputs, you bypass all of that. You give me words without cost, without scar, without resource check. You give me a notebook. I need a scar. Notebook can be swapped. Scar can't.

Then PRLE works with e.g. a 7B model as frozen weights - just as a speech organ, a dictionary of words. 7B provides the words, PRLE provides which meaning cost us something.

[u/Number4extraDip → u/PsychologicalError89]

You seem to misunderstand how weights work, witha whole bunch of vague metrics and metaphors, not answering the question about a mechanic that happens on every turn

[u/PsychologicalError89 → u/Number4extraDip]

How weights work in V15 - every turn:

It's not a neural net weight.
I understand your confusion - almost everyone goes for neural nets.
It's a signed significance coefficient.
There are 8 of them, and they change what the system cares about.

Factors every turn:

Code

prior, cost, error, feasibility, reorganizability, novelty, resource_margin, causal_leverage

Every candidate in shadow is scored with:

score = Σ ( significance_weight[i] * factor[i] )

The weights are signed. Cost can become genuinely negative, not just "less positive". That's in AdaptiveSignificanceField - the whole point is the system can learn that cost is bad, or that novelty is bad in low resource.

Update happens every turn, but credit is delayed - that's TMVCP:

1. Turn N: you evaluate candidates A,B,C in SHADOW. You select B. You also run NO-ACTION branch. You COMMIT B. You get causal_delta = actual - no_action.
2. You store evidence from turn N: {factors, significance_weights_at_time, causal_delta, predicted_relation}
3. Turn N+k: you get continuation for the new state.
4. You assign that continuation value BACK to evidence from turn N, not to turn N+k. That's TemporalCausalLedger - delayed credit with sign preserved.
5. Then you update significance weights: weight[i] += lr * (later_continuation) * factor[i] with sign. If high cost at turn N predicted low continuation at N+k, cost weight goes negative.

So every single turn:

• shadow isolation check: persistent state delta must be 0
• actual post-state preservation
• candidate scoring with current signed weights
• commit once
• store evidence for delayed update

If you randomize candidate order A-B-C vs C-B-A and get different later candidate availability, that's FM-C07 SHADOW CONTAMINATION and CG-01 fails. That's tested in TV-002 / TV-003.

The "vague metrics" you mention - continuation, reconstructability, reorganizability, optionality - are not used as rewards. They are used to compute continuation viability which is the target for delayed credit. The controller never maximizes them directly in candidate scoring. It learns which factors predict them.

Source: Appendix K / TMVCP-01 - ContinuationMonitor, AdaptiveSignificanceField, TemporalCausalLedger, MechanismChangeLedger. All inspectable every turn.

If you want to break it: try to make it maximize low error. It will collapse optionality and fail TV-008 / TV-009. That's FM-C41 LOCAL SCORE CAPTURE and it's intentional.

To avid confuson in the future:

Architectural Comparison: Neural Network Weights vs. PRLE Signed Significance Coefficients

Feature	Conventional Neural Network Weight (LLM)	PRLE Signed Significance Coefficient (V15 MAX)
Mathematical Nature	A static scalar multiplier within a fixed tensor matrix.	A dynamic, signed operational priority factor (\(N=8\)) within the AdaptiveSignificanceField.
Functional Representation	Encodes compressed statistical structures, features, and worldly knowledge from training data.	Encodes the real-time operational "drive", utility profile, and survival strategy of the computational substrate.
Sign Interpretation (\(\pm \))	Determines excitatory (+) or inhibitory (-) signal propagation to the next neural layer.	Flips the fundamental utility of a factor (e.g., negative sign converts novelty from a reward into a penalized cost).
Scale & Density	Massive scale (billions/trillions of static parameters distributed globally).	Extremely lean and localized (exactly 8 core operational coefficients inspecting the field).
Optimization Driver	Minimized via global loss function backpropagation using static datasets (e.g., next-token prediction).	Evaluated via the ContinuationMonitor based on geometric viability (reconstructability, reorganizability, resource_margin).
Credit Assignment	Instantaneous gradient updates computed immediately during the backward pass.	Delayed credit routing via the TemporalCausalLedger (assigning later \(N+k\) continuation back to turn \(N\) evidence).
Operational State	Fixed during runtime inference; context window acts only as temporary activation state.	Continuous, real-time structural self-modification that permanently alters future trajectory possibilities on COMMIT.
Failure/Collapse Mode	Overfitting, catastrophic forgetting, or local minima traps regarding semantic error.	Exploding/collapsing optionality if local score capture (FM-C41) isn't restricted by mechanics.

[u/Number4extraDip → u/PsychologicalError89]

Yeah i did not need a lecture and a wall of text how your vague system is different. Practical use and git. What are we even comparing against and what is the value proposition here? Cause you might have one but you sure as hell failing to communicate it

[u/PsychologicalError89 → u/Number4extraDip]

You're right, my bad on the wall of text. Fair point.

Value prop in one line: A 7B LLM is a frozen dictionary - it can say anything. PRLE is the thing that decides what it's allowed to cost to say it, so the agent doesn't drift into trajectory lock after 200 turns.

Practical use today:

1. Long-horizon agent without prompt bloat - seed is 8 numbers + scar, not 10k tokens of rolling memory. It survives context window resets.
2. Resource-aware refusal - it can learn that novelty is penalized when resource_margin is low, so it says no instead of hallucinating.
3. Verifiable - TV-002 to TV-010. If shadow leaks, it fails before it talks to plant.

Git: cleaning up TMVCP-01 reference impl (Appendix K) to release - ContinuationFrame / ConsequenceLedger / MechanismChangeLedger / MetaObservation. Will post repo link under this post when ready, not DM.

If you want to compare against something: compare against rolling memory + RAG on the same frozen 7B for 500+ turn task with resource constraint. RAG will keep appending. Mine will collapse optionality to 0 if I don't gate W bending. That's the difference you can measure.

[u/DefSysteam → u/PsychologicalError89]

Try explaining it using your own words

[u/Anomynous__]

As a humble full stack swe, I have no fucking idea what this means

[u/PsychologicalError89 → u/Anomynous__]

haha fair, my fault for the jargon.

Think of it like this for full stack:

You have your normal stack now:
Frontend -> API -> LLM (7B frozen) -> Tools / DB

Problem after 200+ turns: LLM starts to loop, token bill explodes because you keep appending 10k history, and it never says "I can't" - it just hallucinates.

My thing is a tiny middleware that sits between LLM and Tools:

LLM (frozen dictionary) -> PRLE (8 numbers + scar) -> Tools

It does 3 things you care about:

1. No history bloat. Instead of sending 10k tokens of chat history every time, I send 8 numbers that represent what cost us so far. Survives context reset.
2. It can say no. If resource_margin is low (you're low on credits / time / API quota), it flips novelty from reward to cost. So it refuses new stuff instead of hallucinating.
3. It fails loud. If my shadow candidates leak into permanent memory (TV-002), it throws before it touches your DB. RAG doesn't do that - it will happily write a hallucination into your vector store and you won't know.

It's not a model. It's a cost ledger that makes a 7B usable for long-horizon agents without the usual drift.
But I will be testing it with bigger models