Bernie Sanders urged OpenAI’s Sam Altman, Anthropic’s Dario Amodei, and Meta’s Mark Zuckerberg to immediately pause AI development to protect humanity. He warned about uncontrollable AI, biological threats, job losses, and dangers to democracy.

Source: https://www.ft.com/content/53082739-7714-4aae-9816-e55ab423cbee

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.