I wondered if...
intelligence didn't live inside one giant model, but emerged from a persistent network of smaller specialised modules?
An experiment exploring whether a modular cognitive architecture can learn continuously, adapt its own structure and retain experience without relying on a single monolithic model.
The Question
Working on Morris left me with a question I couldn't shake.
Modern AI systems are incredibly capable, but they all seem to have an Achilles' heel.
Large language models scale remarkably well, but every request requires loading the same enormous model into memory. Their knowledge is largely fixed, memory has to be bolted on afterwards and every conversation starts with essentially the same brain.
Traditional neural networks are almost the opposite.
They're compact, can be trained efficiently for specific problems and are capable of learning remarkably well, but they don't naturally scale into general-purpose reasoning systems.
That made me wonder.
What if intelligence wasn't one giant model at all?
What if it was a collection of small specialist modules that could communicate, learn, adapt and grow over time?
More importantly...
What if the system itself wasn't stateless?
The Problem
Most AI systems today feel surprisingly disposable.
A request arrives.
The model loads.
It generates an answer.
Then, apart from whatever external memory has been attached to it, everything effectively disappears again.
Humans don't work like that.
Our brains don't wake up from scratch every morning.
Experiences change how we think.
Frequently used pathways become stronger.
Old ideas are forgotten.
New concepts become connected.
The structure itself changes over time.
I wanted to explore what that might look like in software.
Not by building a better language model.
By building something that could remain alive between interactions.
The Hypothesis
The central idea behind NeuroKernel is surprisingly simple.
Instead of one enormous model responsible for everything, imagine a persistent network of smaller specialist modules.
Each module only needs to solve a very small problem.
Signals move through the network.
Useful paths become stronger.
Unused paths weaken.
New modules can be created.
Successful patterns can be consolidated.
Goals influence attention.
Experience changes the structure of the system itself.
Language models still have a place.
Rather than being the entire intelligence, they become specialists responsible for language, sitting alongside many other capabilities inside a much larger cognitive system.
Whether that produces better intelligence is still an open question.
That's the experiment.
The Journey
NeuroKernel grew directly out of Morris.
Morris had already convinced me that symbolic reasoning still had an important role alongside language models.
It also convinced me that building increasingly large systems around a single reasoning engine probably wasn't the direction I wanted to continue exploring.
The question shifted.
Instead of asking how to make one system smarter, I started asking how intelligence itself might organise.
That naturally led towards graph structures, specialist modules, persistent memory, adaptive routing and continual learning.
The architecture slowly evolved into something that feels less like a traditional AI model and more like an operating system for cognition.
Whether that's the right analogy is still something I'm exploring.
The Unexpected Experiment
NeuroKernel also became another experiment in AI-assisted engineering.
When I started Morris, AI was still struggling to produce reliable Python.
By the time NeuroKernel began, frontier models had become capable enough that I could genuinely explore architectural ideas that would previously have taken me years to prototype.
That doesn't mean AI designed NeuroKernel.
Far from it.
It became a research partner.
I could challenge assumptions, discuss ideas, build prototypes, critique architectures and rapidly test alternatives before committing to code.
The result is a project that simply wouldn't have existed without modern AI tooling.
Not because AI wrote it.
Because AI lowered the barrier to exploring ideas that would previously have felt beyond my reach.
Architecture
NeuroKernel is organised around several independent feedback loops.
A reactive loop processes signals and makes predictions.
An adaptive loop evaluates the health of the network and proposes structural changes.
A control loop manages goals, attention and coordination.
A consolidation loop identifies successful patterns and strengthens useful structures over time.
The runtime persists events, supports replay, tracks graph evolution and allows new specialist modules to emerge as the system learns.
The language model is deliberately treated as one specialist among many rather than the centre of the architecture.
The graph is the state, which is the whole point. The language model sits in the middle of the drawing because it is hard to place anywhere else, not because it is in charge.
What Went Wrong
The biggest challenge hasn't been writing the software.
It's been designing experiments that genuinely prove the hypothesis.
Building another adaptive mechanism is relatively straightforward.
Demonstrating that it produces useful learning rather than increasingly elaborate memorisation is much harder.
I've also discovered that cognitive architectures grow incredibly quickly.
Every useful idea creates another subsystem.
Memory suggests consolidation.
Consolidation suggests abstraction.
Abstraction suggests planning.
Planning suggests specialists.
Specialists suggest communication.
The architecture can easily become more interesting than the experiments themselves.
Keeping those two things balanced has probably been the hardest engineering challenge so far.
Lessons
- Continual learning is far easier to describe than to measure.
- Persistent state changes the kinds of questions you can ask.
- Small specialist components are easier to reason about than one enormous system.
- Verification becomes more important as adaptive behaviour increases.
- AI dramatically lowers the barrier to exploring unfamiliar research areas.
- The architecture should never become more important than the hypothesis it's trying to test.
Current State
NeuroKernel is showing encouraging signs.
Modules adapt.
The graph evolves.
Signals route differently over time.
Patterns emerge that weren't explicitly programmed.
Whether those changes represent genuine learning or simply increasingly sophisticated memorisation is exactly what I'm trying to establish.
I'm deliberately resisting the temptation to declare success too early.
The interesting work now is designing experiments that can prove—or disprove—the central hypothesis.
If the evidence eventually says the architecture doesn't offer anything fundamentally useful, I'll happily throw it away.
That would still be a successful experiment.
Next Questions
- Can the system genuinely learn new capabilities without catastrophic forgetting?
- Do specialist modules outperform a monolithic approach for long-running tasks?
- Can useful abstractions emerge naturally?
- How large can the graph become before coordination breaks down?
- Can intelligence be grown incrementally rather than trained all at once?
- Where should language models sit inside a broader cognitive architecture?