I wondered if...
you simulate a field of coupled oscillators, can you make the patterns in it mean something?
An attempt to build a computer out of a wave simulation, then teach it to reason, then let a language model write programs for it. It ran, it taught me a great deal, and it stopped after ten weeks.
The Question
Morris didn't begin as an AI project.
It began while I was writing a science-fiction novel.
Trying to explain the fictional physics behind that universe led me to build a small simulation called RippleNet. It wasn't intended to become anything more than a way of exploring an idea.
Then I noticed something.
The simulation naturally settled into stable patterns.
Those patterns persisted.
They interacted.
They changed over time.
That made me wonder whether those patterns could represent information.
Once that question appeared, the project quietly escaped the original plan.
Could a wave simulation become a computer?
And if it could become a computer...
Could it eventually become something capable of reasoning?
The Problem
Around the same time, large language models were becoming genuinely useful.
I found them fascinating, but I also found them frustrating.
They could produce remarkable results, yet most of the reasoning happened inside a black box.
I wanted something I could inspect.
Something where I could stop the program, examine every step and understand why it had reached a particular conclusion.
RippleNet already gave me a system I understood completely.
Every interaction was visible.
Every value had a reason for existing.
That led to another question.
Could a symbolic reasoning system sit on top of that substrate, with a language model acting as another tool rather than the thing doing all the thinking?
The Hypothesis
The idea sounded wonderfully unreasonable.
If stable regions inside the simulation could reliably represent information, perhaps they could become registers.
Registers become memory.
Memory becomes computation.
Computation makes symbolic reasoning possible.
If a symbolic system could expose its reasoning to a language model, perhaps the language model could become better at planning and problem solving while still allowing every decision to be inspected.
I had absolutely no idea whether any of that would work.
That seemed like a perfectly good reason to build it.
The Journey
The project grew one question at a time.
RippleNet came first.
RippleNet produced stable patterns.
Stable patterns suggested storage.
Storage suggested computation.
So I built a CPU.
Once I had a CPU, I needed a way to program it.
That became RippleLang.
Programming the system naturally led to symbolic reasoning.
Eventually I connected a locally hosted language model so it could generate RippleLang programs, interact with the symbolic layer and make use of tools around it.
At some point I realised I had accidentally built a symbolic AI platform around a speculative physics simulation that originally existed to support a science-fiction novel.
That wasn't where I expected the project to end up.
It rarely is.
Each layer exists to make the one below it usable. Drawn as a stack because that is honestly how it was built — one question at a time, upwards.
The Unexpected Experiment
Morris also became an experiment in something I hadn't planned.
I started the project during the GPT-4 era, when AI coding assistants were still very young. Back then they occasionally struggled with Python syntax, never mind helping build a symbolic reasoning platform inspired by AI research from the 1970s.
Part of me simply wanted to see how far I could push the technology.
Could AI help me build something well beyond my existing knowledge?
The answer surprised me.
Instead of spending years learning enough mathematics, symbolic AI and computational theory before attempting the project, I found myself learning those subjects while building it.
AI became a guide rather than a replacement.
I could ask questions, explore unfamiliar ideas, build experiments, observe the behaviour and then work backwards to understand the theory that explained what I'd just seen.
That completely changed the way I learn.
Without AI tooling I would probably never have started Morris.
The barrier to entry would simply have been too high.
Instead of spending years preparing to ask the question, I could begin exploring immediately and learn the theory as the project evolved.
One of the biggest surprises has been how approachable the mathematics became.
Rather than staring at equations on a page, I could change a parameter, rerun the simulation and watch the behaviour change.
For the first time I wasn't just reading the maths.
I could almost touch it.
Cause and effect became something I could actually see.
That suits the way I learn far better than studying for years before building anything.
Trusting the Machine
Working this way also forced me to rethink software engineering itself.
GPT-4 was remarkably capable for its time.
It was also capable of confidently generating code that looked entirely believable while quietly doing something completely different from what I thought I'd asked for.
Occasionally it even invented implementations that produced the output I expected without actually solving the problem.
Finding those became part of the engineering process.
Read the code.
Question the assumptions.
Write tests.
Verify the behaviour.
Even today there are small parts of Morris that I don't completely understand.
A few years ago I would have found that deeply uncomfortable.
Now I think it's simply another level of abstraction.
When high-level languages first appeared, many developers checked the assembly generated by the compiler line by line.
Today I never think about the machine code produced by C#.
We gradually learned to trust the abstraction because experience showed us when it deserved that trust.
AI feels like the next step along the same path.
The difference is that today's abstractions are still young.
Trust has to be earned.
What has been particularly interesting is watching newer models revisit parts of the project.
GPT-4 occasionally filled gaps with convincing nonsense.
As the frontier models have improved, many of the underlying ideas have continued to hold up remarkably well.
That has been one of the most encouraging outcomes of the entire experiment.
What Went Wrong
The biggest unanswered question is still the one that matters most.
Does the RippleNet substrate actually contribute anything useful?
The symbolic reasoning works. RippleLang works. The AI integration works. The simulation works.
What I still can't honestly answer is whether combining them produces something fundamentally better than a conventional symbolic reasoning system. That remains the question at the heart of Morris.
This is where the honest doubt lives. The loop closes, but I picked the threshold and I named the symbol, so the meaning arrives from me rather than emerging from the field.
The project also became much larger than I intended. Every interesting answer seemed to create two new questions.
Before long I had accumulated a CPU, a programming language, reasoning engines, plugins, local models and more services than any one-person research project had any right to possess.
I don't regret that.
Several of those side quests have already influenced completely different projects.
Lessons
- AI dramatically lowers the barrier to exploring unfamiliar fields.
- Learning while building suits me far better than learning before building.
- Verification matters far more than generation.
- Symbolic reasoning still has a valuable role alongside language models.
- Building infrastructure is easier than designing experiments that genuinely test a hypothesis.
- Interesting questions have a habit of producing completely different projects.
Current State
Morris is currently paused for a very practical reason.
Resources.
To run the version I actually want, I need a local language model, the RippleNet simulation, the symbolic reasoning layer, diffusion models, memory, supporting services and enough GPU capacity to run them together without everything grinding to a halt.
Realistically, that means hardware costing somewhere around £15,000. I am not spending that on a side project and I am definitely not turning Morris loose inside a cloud account.
Given enough access, compute and poor judgement, he would probably set fire to a data centre.
So for now Morris remains contained on hardware I control, running in smaller pieces when I want to test a specific idea.
The project is still active in the sense that the questions have not gone away. The limiting factor is no longer whether I know what to build next. It is whether I can run the thing safely and affordably once I have built it.
Next Questions
- Can stable symbols emerge naturally rather than being defined by me?
- Does the substrate genuinely improve reasoning?
- Could Morris support other reasoning systems besides language models?
- What would I deliberately leave out if I started again?
- How much can AI accelerate research without sacrificing understanding?