It’s Saturday morning in lovely Brisvegas Australia and I am sipping a coffee whilst writing this article. Sneaking peeks out over the calm ocean. And pondering over my thoughts. For the last few weeks I’ve started exploring what I am calling The Reasoning Engine.
Figure 1. The Reasoning Engine Architecture
And yes… it sounds a little ambitious. Maybe slightly mad. But I think there is something sitting in this idea that is worth chasing.
Because the more I work and develop with AI, the more I keep coming back to the same problem. We are building systems that are very good at producing answers, summaries, reports, emails, classifications and outputs. But we are still not doing enough to capture the reasoning behind those outputs.
And to me… that is where the real value sits.
The output is useful. No question about that. But the reasoning is where the judgement lives. It is where the assumptions sit. It is where the risks are weighed. It is where the “why did we go this way and not that way?” stuff exists.
Figure 2. From raw thought to structured reasoning
And most of the time, that thinking disappears.
It disappears in meetings. It disappears in someone’s head. It disappears in Teams chats, rough notes, draft documents, half-finished conversations and all the messy places where real work actually happens.
We save the final version. We lose the thinking. That feels like a problem worth solving.
So my first step is not to try and build some giant magical AI model from scratch. That would be ridiculous at this stage. Expensive, slow, and probably the wrong starting point. The smarter path, I think, is to build the system around the reasoning first.
In other words, I am not trying to build the “brain” on day one. I am trying to build the capture layer, the structure, the memory, the feedback loop and the learning process. That is where the engineering starts.
The first version of the Reasoning Engine would be fairly simple. A person writes or speaks a thought into the system. The system then extracts the reasoning from that thought. It looks for the claim, the assumptions, the risks, the examples, the possible counterarguments and the implications.
So instead of simply storing a sentence like:
“AI governance cannot just be a policy sitting in a folder.”
The system would try to understand what sits underneath it.
The claim might be that static governance documents are not enough. The assumption might be that AI systems change over time. The implication might be that governance needs to be active, monitored and updated. The related concept might be AI Living Governance.
That is the beginning of the engine.
Not just storage. Structure. Not just memory. Reasoning memory.
The first engineering step is to create a reasoning schema. This is basically the shape of the data I want the system to capture each time I give it an idea.
Something like:
Figure 3. Reasoning Engine JSON Structure
That might look a bit technical, but the idea is simple. Every thought gets broken into the parts that make the reasoning visible. Because once the reasoning is visible, we can start doing something with it.
We can search it. We can compare it. We can test it. We can improve it. We can link it to other ideas. We can see how thinking changes over time.
And that is where things start getting interesting.
The second step is building a simple capture interface. Nothing fancy. Just a place to put a thought into the system. It could be a text box. It could eventually be voice. It could be connected to notes, articles, decision logs, meeting summaries or research material.
But at the start, simple is better.
A box. A button. A thought. Capture it.
Then the system sends that thought through a reasoning extraction layer. At first, that would probably use an existing large language model. I do not need to train a full custom model at the beginning. That would be overkill.
The LLM can act as the first extractor. Its job would be to take a messy human thought and return structured reasoning.
Something like:
What is the main claim? What assumptions are being made? What risks are being identified? What is the wider implication? What concept does this connect to? That gives me the first dataset. And that matters. Because machine learning is only as good as the data it learns from.
This is where a lot of people get excited about models too early. They want the model before they have the learning material. But for the Reasoning Engine, the valuable thing is not the model at the start.
The valuable thing is the reasoning data.
Clean reasoning data. Structured reasoning data. Corrected reasoning data. Human-reviewed reasoning data.
That is the gold.
The third step is storing the reasoning properly. I would probably start with a normal database like PostgreSQL. Store the raw thought. Store the structured reasoning. Store the date. Store the source. Store the related concepts. Store any corrections I make later.
Then I would add a vector database or something like pgvector so the system can search by meaning, not just keywords.
That means if I write something about “capturing judgement behind AI decisions”, the system could find older thoughts about “institutional intelligence”, “living governance”, “decision traceability” or “defensible AI”, even if I used different words.
That is important.
Because reasoning does not always repeat itself in the same language. Sometimes the same idea comes back wearing a different hat. The fourth step is building the feedback loop. This is where it starts to become more than a filing cabinet.
The system extracts the reasoning, then I review it.
I might say:
“No, that is not quite right.” “This is more about governance than technical design.” “You missed the legal defensibility point.” “This should connect to AI Living Governance.” “This idea is not mature yet, but it is worth developing.”
Every correction becomes training data. That is the beginning of the machine learning process. Not some big dramatic thing.
Just a learning loop.
Figure 4. The Learning Loop
The AI extracts. The human corrects. The system stores the correction. The next extraction gets better. That is how the Reasoning Engine starts to learn. Over time, if there are hundreds or thousands of corrected reasoning entries, smaller machine learning models can be trained on top of that data.
One model might learn to classify the type of reasoning.
Is this legal reasoning? Governance reasoning? Technical reasoning? Operational reasoning? Strategic reasoning? Ethical reasoning? A product idea? A risk analysis?
Another model might learn to identify which concepts an idea belongs to. Another might score whether an idea is rough, developing, framework-ready or ready to become part of a paper, book, article or governance model. Another might detect contradictions.
That last one really interests me.
Because if I make a claim today, and six months later I say something that conflicts with it, I want the system to notice. Not to tell me I am wrong.
But to say:
“Hey, this seems to shift your earlier reasoning. Has your thinking changed?”
That is powerful. This becomes particularly important in legal matters where case law or legislation may have changed or shifted and requires a different approach.
That is not just AI producing content. That is AI helping build intellectual discipline.
The fifth step is creating the reasoning graph. This is where all the ideas start connecting.
A thought about AI governance might connect to AI Trust. AI Trust might connect to explainability. Explainability might connect to legal defensibility. Legal defensibility might connect to evidence. Evidence might connect to decision records.
Figure 5. The Reasoning Graph
Suddenly, the system is not just storing notes. It is building a map of reasoning.
A living map.
That is where the Reasoning Engine starts to tie directly into my bigger concept of AI Living Governance. Because governance cannot just be a policy sitting in a folder. I keep saying this because I think it matters.
A policy in a folder is not living governance.
- It is paperwork.
- Useful paperwork maybe.
- But still paperwork.
Living governance needs to monitor how decisions are being made. It needs to understand the reasoning being relied on. It needs to detect when assumptions change. It needs to identify when a system drifts away from the logic it was originally trusted to follow.
So the Reasoning Engine becomes more than a personal research tool. It becomes a possible governance layer.
Not just: “What did the AI output?”
But: “What reasoning sat behind that output?” “What assumptions were used?” “Was the reasoning sound?” “Was the reasoning reviewed?” “Can the decision be explained?” “Can it be defended later?”
That is where I think this research starts to matter. Especially as AI moves from writing and summarising into decision support, automation and agentic systems. Once AI starts influencing real decisions, reasoning becomes a serious issue.
Not a nice-to-have. A serious issue. So the engineering process I am looking at is something like this:
Capture the thought. Extract the reasoning. Structure the reasoning. Store the reasoning. Connect the reasoning. Correct the reasoning. Learn from the reasoning. Apply the reasoning. Govern the reasoning.
That is the path.At the moment, I am still at the early stage. Very early. This is not some polished product announcement. It is not a “look at my finished thing” post.
This is me thinking out loud as I start the build.
There will be rough code. There will be weird diagrams. There will be things that break. There will be moments where I realise I have overcomplicated something that should have been simple.
Standard Saturday fun really…But I think the idea is worth chasing. Because I do not think the future of AI is only about bigger models. I think the future of AI is also about better reasoning systems.
- Systems that capture the “why”, not just the “what”.
- Systems that help humans preserve judgement, not replace it.
- Systems that make decisions more explainable, more testable and more defensible.
That is what I want to explore with the Reasoning Engine.
It starts small.
A thought box. A schema. A database. A feedback loop. A learning layer.
But if it works…It could become something much bigger.
- A way to capture reasoning as an asset.
- A way to build living governance around AI.
- A way to stop losing the thinking behind the work.
And honestly…That feels like a pretty bloody interesting place to start.
Figure 6. The Reasoning Engine Cheat Sheet