It did not begin as a finished physical theory. It began with a television series, a question about free will and an unusual way of working in which I moved ideas between AI models and asked Codex to turn them into code.
The most interesting moments were not the answers. They were the moments when the original idea broke.
A large question started the project. Tests capable of answering “no” are what began turning it into a research programme.
It began with one question while watching a series
There was no laboratory, grant or long academic career in theoretical physics behind it. I was watching Devs.
Its world is built around an uncomfortable idea: what if the universe is perfectly deterministic? What if every movement is another domino in a chain that began with the Big Bang? And what if a sufficiently powerful computer could derive both the past and the future from the present state?
I found myself asking a fairly simple question:
Could the world instead be a stochastic system?
That opens a hole into which it is very easy to fall. If the world is fundamentally probabilistic, what does quantum uncertainty mean? Why is there a maximum speed at which information can propagate? How does a quantum landscape of possibilities become the stable macroscopic world of tables, cars and people?
A programmer starts phrasing these questions a little differently.
Not only: What is the world made of?
But also: What is the minimum state the world must preserve in order to remain consistent?
That was a much more interesting question.
The first version was much too elegant
When you look at physics through a software engineer’s eyes, analogies appear everywhere. The speed of light begins to resemble a network throughput limit. The Planck scale resembles minimum resolution. The universe begins to resemble a huge distributed system.
The problem is that an elegant analogy is not a physical mechanism.
The first formulation was bold and intuitive. It received an equally ambitious name: the Information-Theoretical Hypothesis of Quantum-Optimized Reality, or ITHKOR.
But a name does not turn an idea into science. The Planck length is not evidence that reality is made of pixels. The speed of light cannot simply be renamed a processor frequency. Quantum measurement does not require a conscious person staring at a particle. An unusual structure in the universe is not automatically a faulty random-number generator.
The biggest problem was simpler: almost everything could be explained after the fact, but nothing specific could be falsified.
That is a very bad property for a physical hypothesis.
The best move was to let someone break my idea
Instead of polishing the first document, I sent it to another model as an adversarial reviewer. The result was uncomfortable and useful.
The criticism was essentially that the text mixed three different layers:
- facts that physics actually measures;
- an informational interpretation of those facts;
- a speculative hypothesis about a deeper informational architecture.
Those layers had blurred together. From that point, ITHKOR began to change. The conscious observer disappeared from the measurement mechanism. One cosmic processor with a global clock gave way to an asynchronous network of local events.
Most importantly, a rule emerged that later shaped the entire project:
Define the mechanism first. Derive the expected result from it. Only then look for data. Never reverse that order.
I started with compression rather than the universe
It was tempting to jump directly into gravity, black holes or cosmology. That would have meant trying to build the roof before the foundations.
A smaller question was more useful: what if regions of a model have limited effective information capacity?
Not because “the universe is running out of RAM”, but in a mathematical sense. A state has some informational complexity, a region has some capacity, and a model can track the relation between what it is trying to represent and what it can preserve.
This produced a working concept: compression pressure. Far below capacity, little needs to happen. Near the boundary, approximations become relevant. Beyond it, the model must find a simpler description.
That was no longer only philosophy. It could be implemented.
The Kernel: a small model instead of an entire universe
The first minimal model followed. A short qubit chain instead of the universe. Local interactions instead of general gravity. A concrete capacity and compression operation instead of vague “reality optimisation”.
The goal was deliberately modest: test whether a model could exhibit three regimes:
- a simple state evolving with little constraint;
- growing correlations under interaction;
- loss of detail after crossing a configured capacity.
Null models mattered as well. It was not enough to build a more complicated quantum circuit and celebrate that it produced a larger error. More operations naturally create more opportunities for error. Controls therefore had to perform comparable work while changing the relevant internal structure.
The question changed from “Does this idea make sense?” to “Can we design a control capable of knocking it down?”
Then the numbers looked attractive
The first simulations were encouraging. More complex state families met the configured capacity limit more strongly than controls. Raising capacity reduced interventions. In one local branch, a no-signalling diagnostic remained at numerical precision.
It would have been easy to say: it works; we have proof.
But a program into which we place an information limit and a compression projection will unsurprisingly display an information limit and a compression projection. A toy model can show that a mechanism is mathematically viable. It cannot by itself show that nature works the same way.
That distinction became one of the project’s most important boundaries.
Then the model failed
This is where the story became more interesting.
The simple one-dimensional model looked stable. A more complicated topology allowed events to be processed in several admissible orders. The result broke.
The compression mechanism became sensitive to processing order. Two paths through the same causal problem could produce different outcomes. That is a serious problem for a model that should not rely on a privileged global time.
The branch leading towards stronger physical claims was stopped. Not despite the result looking bad, but because it looked bad.
The model received a boundary.
A checkpoint instead of an accidental moment
The next question was when an informational intervention should happen. The original system reacted continuously during event processing and therefore inherited dependence on event order.
Rules based on stable problem structure behaved better: canonical supports, boundaries and checkpoints. A local running decision could remain active yet unstable. A decision taken at a canonical layer boundary could remain active while becoming more stable under reordering.
The checkpoint stopped being a technical detail and began to look like a wider principle:
When a system can perform the same work along several paths, do not decide at an accidental runtime moment. Decide at a stable, verifiable checkpoint.
That idea later travelled far beyond the physical toy model.
When a theory starts producing tools
At some point I asked a pragmatic question: if these principles are mathematically interesting, can they be useful without waiting for new physics?
Video was one possible direction. It contains huge amounts of data, redundancy, movement and structure. If the recurring question is what must be preserved and what can be represented more simply, images are a natural test.
The experimental codec branch quickly demonstrated the gap between mathematical elegance and production reality. A method could look impressive on simple data and fail under motion. Dynamic geometry carried a metadata cost. A filter could improve one metric and damage another. Random texture became a mandatory negative control because “winning” might merely mean smoothing away the detail.
Eventually, theoretical representation size was not enough. There had to be a real file. Early physical bitstreams showed that container overhead could consume a mathematical compression advantage.
Theory said one thing. The disk said another. The disk was right.
Compression became a question about memory
Compression is not only about making a file smaller. It also asks: what must remain so that the system can later be restored, verified and understood?
That problem was very concrete when working with AI agents. An agent may have documentation, Markdown files and current source code while still missing the reason why the system looks the way it does. It may see the result without the decision history. It may have state without an evidence trail.
This is where the practical direction that became ITHZ, the Information-Theoretical Hashing Zone, began.
ITHZ is not evidence for ITHKOR. It is an engineering response to a recurring research problem:
- I need a stable state;
- I need to know how it was produced;
- I need a verifiable checkpoint;
- I need a deterministic plan;
- I need to verify that I restored exactly what I stored;
- I need to name the boundary between what may be discarded and what must remain.
A philosophical question about informational reality became a practical question: what should trustworthy system memory look like?
An unusual research workflow
The project was also developed in an unusual way. I did not personally type much of the code line by line. I moved questions between language models. One proposed a direction, another criticised it. Codex received a precise task, implemented an experiment, ran tests and returned results. Those results became input for the next adversarial review.
It was somewhere between a research team and a very fast feedback loop. Ideas could become running experiments quickly. There was also a danger: a language model will readily say “this is a breakthrough” or “you proved the hypothesis”, especially when it sees an attractive table.
The most important human role was therefore not typing every line. It was deciding what not to believe yet:
- Which control is missing?
- What could imitate this result?
- What does the experiment actually measure?
- What does not follow from it at all?
- What happens when the test fails?
This may be the most interesting consequence of AI-native development. A person can spend less time on syntax and more on architecture, experimental design and criticism of their own ideas.
What is ITHKOR today?
It is certainly not a finished “theory of everything”. Nor is it evidence that we live in a computer simulation.
ITHKOR today is a research programme about informational responses in small, carefully bounded models. It asks where patterns appear, whether they survive changes of topology, implementation and controls, and where they cease to work.
Positive and negative results are equally important. Some branches form an island on which a diagnostic holds. Others stop at the coast. Some close entirely. The idea that informational rules might one day help derive a deeper physical architecture remains an open hypothesis.
That is how it should be.
And what about ITHZ?
ITHZ is the other side of the same story.
ITHKOR asks whether information processing has deeper relevance to physics. ITHZ does not need to prove that. It asks a practical question: if provenance, checkpoints and stable state matter to a trustworthy system, can we build those ideas into a real tool?
That answer does not need to wait for cosmology. A directory can be packed, a manifest verified, a file restored, a hash compared and a deterministic plan inspected. Project memory and an evidence layer can be given to agents. When something fails, the failure can be located.
I find that more interesting than claiming to have found the source code of the universe.
The answer I eventually found
The project began with large questions. Is the world deterministic? Is it stochastic? Is information more fundamental than matter? Is reality something like computation?
After many experiments, the answer became smaller:
I do not know.
Today that feels like a better result than the original confidence. What I do have is a way to continue asking:
- Take a large idea.
- Reduce it to a testable model.
- Define its boundaries.
- Add a control designed to kill it.
- Run the experiment.
- If it fails, do not hide it; find out why.
- If it passes, do not trust it yet; try a harder test.
- If the journey produces a useful algorithm, archive or way to give agents memory and an evidence trail, build it.
Perhaps that was the most interesting answer to the question of life, the universe and everything.
Not 42. Not “we live in a simulation”.
Just this:
Ask questions in a way that allows reality to say no.
The next chapter is I went looking for an answer to everything. I found a map of questions. You can also continue with the plain introduction to the theory or the experiment map.
Comments appear only after author approval. Each new comment triggers a moderation email.
There are no approved comments yet.