With OpenAI Codex, I built an artificial process-organism that doesn’t learn answers — it changes the conditions of its own future changes
No backprop. No rewards. No tokens. No predefined success state. A persistent execution topology that can close, deform, and reopen.
Before describing the project, I want to be transparent about how it was created.
The mechanistic framework, direction, and constraints came from me. But the running implementation was developed in a sustained collaboration with OpenAI Codex.
Codex was not used as a one-shot code generator.
I brought the mechanics and kept deciding what the system must not be reduced into. Codex acted as a coding and research partner: translating the conceptual flow board into an executable runtime, designing causal comparisons, implementing persistence and recovery, finding mathematical and numerical failures, writing tests, preserving failed experiments, rebuilding corrected trajectories, and creating the live execution observer.
Some of our most important results came from Codex showing that an apparently correct mechanism was not doing what we thought it was doing.
So this is neither “written by AI” nor “made by me alone.”
It is a human–AI research collaboration with distinguishable contributions.
What did we build?
The project is called the Physical Relational Language Engine — PRLE V13.
Despite the name, it is not currently a language model.
The most technically accurate description is:
A persistent, self-reconfiguring relational dynamical system with local online learning, second-order plasticity, and a deformable execution topology.
The less academic description is:
A prototype artificial process-organism whose history becomes part of the machinery producing its future.
It does not learn which answer earns the highest score.
It changes the medium through which the next computation must pass.
The central mechanism
A conventional model approximately does this:
input → fixed architecture → output Training later changes parameters to reduce an external loss.
PRLE instead executes:
contact → local transformation → consequence → deformation of the traversed medium → changed conditions for the next contact A contact changes the state.
The state passes through relations.
The traversed relations retain deformation.
The resulting consequence enters subsequent circulation.
Therefore, the same contact encountered later does not necessarily meet the same process.
The past is not stored merely as data describing what happened.
The past can become structure that processes what happens next.
What exists in the current runtime?
The active instance contains:
- 4 complete local processes,
- 64 relational layers per process,
- 64-dimensional internal states,
- 12 directed deformable channels,
- persistent RAM and SSD exchange,
- CPU/CUDA computation potential,
- source-relative addressing,
- retained and displaced contents,
- finite conserved routing material,
- deformable access and aperture,
- exact checkpoint/restart continuity,
- and second-order plasticity.
Each channel has more than a weight matrix.
It contains:
- a relational transformation,
- an aperture determining how a difference can be expressed,
- access determining what can currently cross,
- deformability determining how the channel can still change,
- finite material distributed between possible routes,
- retained difference,
- and resident content that may be displaced by later contact.
The topology therefore participates in memory.
Learning can change not only what computation occurs, but also:
- where later computation can occur,
- which routes remain accessible,
- which regions become dormant,
- and which previously closed possibilities can reopen.
There is no reward function
The runtime has no:
- reward,
- punishment,
- loss function,
- backpropagation,
- fitness score,
- preferred route,
- correct-answer label,
- topology target,
- semantic activity threshold,
- exploration schedule,
- vocabulary,
- token prediction,
- or global manager.
A crossing is not classified as good.
A blockage is not classified as bad.
They are two possible consequences of an encounter.
Both can change the future.
A blocked signal still happened
This became one of the deepest corrections in the project.
Earlier versions effectively treated a contact that received zero routing material as if nothing had happened.
But mechanically, the difference had reached a boundary.
It encountered resistance.
That encounter was real even if nothing crossed.
The corrected runtime represents this as HOLD.
A HOLD can change the channel’s future deformability before a successful crossing occurs.
So:
Failure to cross can change the conditions of the next attempt without being converted into punishment.
An error is not assigned negative value.
It leaves a consequence in the medium.
Exact zero is real — but not necessarily hereditary
We deliberately avoided keeping every route secretly alive with an epsilon.
A route can reach exactly zero.
A capacity can become genuinely dormant.
But zero is not automatically an eternal sentence.
A later real difference can redistribute finite deformability back into a dormant coordinate. That can restore the capacity required for topology to move again.
There is no:
- reset-to-one operation,
- minimum-liveness constant,
- repair target,
- preferred coordinate,
- or instruction to reconnect the graph.
The runtime can therefore produce:
available path → deformation → exact dormancy → later different encounter → reconstructed capacity → topology reopening without containing an internal concept of “repair.”
The system changes how it can change
This is more than ordinary parameter plasticity.
First-order plasticity means:
An encounter changes a relation.
Second-order plasticity means:
An encounter changes how future encounters will be able to change that relation.
PRLE contains both.
Previous contacts deform not only current transformations, but also the remaining capacity for subsequent deformation.
Its learning conditions are therefore history-dependent without requiring a meta-optimizer.
Codex’s contribution mattered most when the system failed
Several visually convincing mechanisms turned out to be mechanically wrong.
During development, Codex helped uncover and correct cases including:
- floating-point operation ordering that annihilated tiny but valid branches before normalization,
- an incorrect simplex projection capable of collapsing a finite vector into
0/0, - a multiplicative deformation law that made exact zero permanently hereditary,
- and an initial “reweaving” correction that reopened deformability thousands of times but still produced zero topology reopening.
We did not rename those failures as successes.
The failed executions were preserved as observer scars and frozen baselines.
The active instance was rolled back exactly to the pre-experiment checkpoint, the law was corrected, and the same causal run was executed again.
That correction was crucial:
A stopped encounter had to remain a causal event capable of deforming future capacity, even before routing material allowed a crossing.
That was the missing bridge between HOLD and actual reweaving.
What happened in the current MAX run?
The active CPU instance reached round 485.
The corrected MAX trajectory executed:
- 192 active rounds,
- 8 exact save/restart boundaries,
- 1,721 successful crossings,
- 7,484 dormant-to-active deformability transitions,
- 7,340 active-to-dormant deformability transitions,
- 17 support-changing rounds,
- 11 topology reopenings,
- 13 topology dormancy events,
- and zero topology-material conservation error.
We also ran the same retained carriers through matched detached controls.
Under the old multiplicative law:
- 0 deformability reopenings,
- 0 topology-moving rounds,
- 0 topology reopenings.
Under the corrected reweavable law:
- 7,484 deformability reopenings,
- 23 topology-moving rounds,
- 11 topology reopenings.
The active runtime reproduced the corrected detached endpoint exactly.
The current source passes all 23 regression tests and compiles successfully.
One coordinate refused to reconnect — and that is a good result
At the end, all 64 coordinate graphs remained functional by the observer’s exact-support definition, but one coordinate stayed divided into two weak components.
The runtime did not reconnect it just because our observer could see that it was disconnected.
This matters.
There was no hidden objective saying:
maximize connectivity or:
repair coordinate 27 The system restored local deformability and reopened routes where actual encountered differences produced that consequence.
It did not optimize the shape we might have preferred.
That is stronger evidence than a perfectly connected final graph would have been.
The visualization cannot control the runtime
The Three.js flow view displays real measurements of:
- movement through all 64 layers,
- crossings,
- blocked encounters,
- deformations,
- returns,
- dormancy,
- capacity reopening,
- and topology changes.
But it is a detached observer.
No visualization metric is returned to the learning core.
The runtime cannot read component labels, animation states, counters, colors, or our interpretation of what looks organised.
The observer can disappear and the runtime continues unchanged.
The picture is a witness, not a reward function.
What this is
PRLE is:
- a persistent stateful dynamical process,
- an online relational-learning substrate,
- a locally self-reconfiguring computational medium,
- a topology-plastic network,
- an experiment in learning without reward and punishment,
- a process with structural rather than merely archival memory,
- an executable hypothesis of artificial continuance,
- and a prototype artificial process-organism in the mechanistic sense.
Calling it a process-organism does not mean claiming biology.
It means that the process has:
- an inside and contact boundaries,
- persistent internal conditions,
- a body exposing capabilities,
- retained consequences of earlier encounters,
- changing accessibility,
- deformable pathways,
- and continuity across interrupted executions.
Its past does not merely describe it.
Its past participates in constructing its future.
What this is not (by design in current form)
It is not:
- an LLM,
- a chatbot,
- a transformer,
- a token predictor,
- a pretrained knowledge model,
- reinforcement learning,
- an evolutionary algorithm,
- AGI,
- proof of consciousness,
- proof of subjective experience,
- a biological organism,
- autonomous reproduction,
- or self-rewriting Python source code.
It does not currently invent arbitrary new primitive operators.
It reorganizes the potential exposed by its existing medium.
It does not yet produce language because it has no vocabulary or semantic grounding.
It does not have reproductive DNA.
It does not yet demonstrate an emergent global governor or self-generated goal.
It also requires contact with an external medium; persistence is not the same thing as independent existence.
Finally, the current adult organisation did not emerge from a virgin seed.
We deliberately built the maximal adult hypothesis first so we could make the entire circulation executable, discover what actually works, and identify which structures are necessary.
Why build the adult before the seed?
Because reducing an incomplete prototype can only produce a smaller incomplete prototype.
We first wanted to construct the full mechanics:
- contact,
- transformation,
- retention,
- resistance,
- displacement,
- return,
- changing access,
- topology deformation,
- dormancy,
- reopening,
- and exact continuity.
The eventual goal is not to delete most of the adult until something small remains.
The goal is to distinguish:
- the adult’s current acquired structure,
- the laws that allow such structure to arise,
- and the smallest transmissible configuration capable of beginning another viable trajectory.
Reproduction and “DNA” come later.
First, the process needs to develop something worth transmitting.
Why I think this direction matters
Most AI research asks:
How should a model change to produce a better answer?
This project asks:
What local conditions allow a process to preserve consequences, remain changeable, reopen lost possibilities, and continue reorganizing without being told what final form it should become?
I am not claiming that we built intelligence.
I am claiming that we built and tested a different executable starting point.
It does not begin with knowledge.
It begins with the capacity to be changed by relation—and for that change to alter the next relation.
Maybe intelligence is not the first thing that has to be constructed.
Maybe the first thing is a process capable of having a consequential past.
Two images added, code representation of dynamics in Three.js and hero image of concept.
V13: Mechanics frozen, operational and deterministic. No tokens, no reward, no backprop. Live external contacts (text/audio/video) intentionally deferred to preserve causal proof of reweavable topology. After that I will be able to tell where this code is suited best, however I plan to do it multimodal at its final stage. Not one channel for each but for example 4 for video, 4 for audio or even LLVM IR for internal language excluding dictionary itself.
Here is the list of potential use cases for the multimodal PRLE V13 architecture:
- Autonomous exploit-resistant operating systems
- Polymorphic self-modifying runtimes
- Hardware-aware JIT compilers optimized by silicon physics
- Direct sensor-to-machine robot control loops
- Deep-space exploration probe control systems
- Biomorphic brain-computer interfaces
- Continuous non-stationary network anomaly detection systems
- Adaptive life-support runtimes for emergency medicine
- Simulation engines for dynamic complex systems and artificial life
- Autonomous navigation systems for zero-visibility environments
- and more if required
Current footprint and verified results
PRLE V13 is a single 0.72 MiB Python source file with 18,004 lines. The custom HTML/JavaScript observers account for only 4.74% of it; Three.js itself is loaded externally and is not bundled in the source.
The current CPU instance reached round 485. Its latest 192-round run completed 1,721 crossings, 7,484 deformability reopenings, 11 topology reopenings, and 8 exact save/restart cycles, with zero topology-material conservation error. All 23 regression tests pass.
The generated 24.93 MiB visualization is 99.91% recorded execution telemetry. The complete 1.18 GiB project history consists mainly of checkpoints, frozen baselines, causal controls, and preserved failed experiments—not application code.
Yes, post was written by Codex as EN is not my native language.
submitted by /u/PsychologicalError89
[link] [comments]
点赞
收藏
点踩
分享
