Part 2: What a geologist accidentally built while trying to stop AI from being confidently wrong.
By Arif Fazil
Geoscientist, Penang
In Part 1, I said something that sounded a bit dramatic.
That as a geologist, I may have accidentally built an intelligence kernel.
Nice phrase.
Very technical.
Very impressive sounding.
There is just one small problem with that story.
I didn’t even know what a kernel was until I rented a cheap VPS for seven US dollars.
I’m serious.
Before that moment, “kernel” was not part of my vocabulary. I’m not a computer scientist. I’m not a backend engineer. I didn’t grow up compiling Linux for fun.
I’m a geologist.
My tools are seismic lines, subsurface maps, and probability of success. My job is basically managing uncertainty while pretending to management that uncertainty is under control.
So if you’re expecting some heroic coding origin story, this isn’t it.
The truth is much less glamorous.
I didn’t start by trying to invent something clever.
I started because something about AI annoyed me.
The irritation
Large language models do something I’ve seen before.
They speak very confidently.
Often before they’ve earned the right.
In geology, that habit gets people into trouble.
A confident interpretation can lead to drilling a well that costs tens of millions of dollars.
Reality doesn’t care how confident you sounded in the meeting.
The rock column always gets the last vote.
So when I started using AI tools, the pattern felt familiar.
The models were impressive.
Fast. Fluent. Helpful.
But they also had the same dangerous habit:
confidence first, evidence later.
That’s tolerable when the output is just text.
But it becomes a different story when the AI is connected to real systems:
- code execution
- deployments
- servers
- databases
- financial decisions
- operational workflows
At that point, a hallucination is no longer a funny mistake.
It becomes a real action.
And that bothered me.
Not philosophically.
Practically.
My first instinct was simple
I did not ask:
How do we make AI smarter?
I asked something much simpler.
How do we stop AI from doing stupid things confidently?
That question is what led to arifOS.
Not as an AI brain.
Not as an agent.
Just as a layer sitting between a language model and the real world.
A pause.
A checkpoint.
A place where someone — or something — asks a few uncomfortable questions before anything irreversible happens.
What arifOS actually does
In plain language, arifOS sits between the AI and the systems it could affect.
The model can still think.
It can still propose.
It can still generate ideas.
But before those ideas become actions, the system checks a few things:
- Is this grounded in evidence?
- Does this action have authority?
- Is it reversible?
- Should a human approve it first?
- Who might be harmed if this is wrong?
If those questions fail, the system does not continue.
It pauses.
Or refuses.
Or asks for clarification.
That’s it.
No magic.
Just structured hesitation.
And honestly, the older I get, the more I think hesitation is underrated.
When I finally learned the word “kernel”
Only later, while experimenting with servers on that seven-dollar VPS, I kept seeing the same word everywhere:
kernel.
At first I ignored it.
Then I realized something interesting.
In an operating system, the kernel is the part that decides what programs are allowed to do.
Applications can ask for resources.
But the kernel decides whether the request is legitimate.
That sounded… familiar.
Because arifOS was doing something similar.
It wasn’t trying to be the smartest voice in the room.
It was trying to be the layer that says:
- “Hold on.”
- “You don’t have authority for that.”
- “That action isn’t reversible.”
- “This isn’t grounded enough.”
- “Ask the human first.”
So the word kernel stuck.
Not because I wanted to sound technical.
Mostly because it described the behavior surprisingly well.
But something unexpected happened
Once those boundaries existed, the model started behaving differently.
Not because the model changed.
The model was still the same model.
Same training.
Same weights.
Same capabilities.
But inside the constrained environment, its posture shifted.
I started seeing patterns:
- it asked for evidence earlier
- it slowed down when situations were unclear
- it separated suggestions from actions
- it avoided irreversible moves
- it explained refusals more clearly
The intelligence hadn’t changed.
But the behavior had.
Which made me start wondering something slightly uncomfortable.
Maybe constraints change conduct
Humans behave differently depending on the environment.
People act one way at a bar.
Another way in a courtroom.
Another way on a drilling rig.
Same person.
Different system around them.
The environment shapes behavior.
So maybe the same thing applies to AI.
A raw language model lives in an environment where the cost of being confidently wrong is almost zero.
Inside a governed system, that cost increases.
Suddenly, hesitation makes sense.
Suddenly, evidence matters.
Suddenly, irreversible actions look dangerous.
The model hasn’t become wiser.
But the system around it makes care the safer strategy.
So is arifOS really a kernel?
The honest answer is:
Yes — but that might not be the most interesting part.
Yes, it behaves like a kernel.
It governs transitions between suggestion and execution.
It separates language from authority.
It forces checks before actions.
But what interests me more now is something else.
Once those rules exist, they don’t just block behavior.
They start shaping it.
The system becomes a kind of environment.
And environments change how things behave inside them.
Is that emergence?
Maybe.
But I’m careful with that word.
I’m not claiming consciousness.
I’m not claiming wisdom.
I’m not claiming a new species of intelligence.
What I’m saying is simpler.
A governed environment can make a model behave more disciplined, more cautious, and more accountable than the same model operating freely.
That may not be mystical.
But it is definitely more than a prompt.
Why any of this matters
Most people don’t care whether something is technically called a kernel.
Fair enough.
What people really care about is simpler.
Can we trust AI near real decisions?
And my answer is:
Not by default.
Not when confident language can turn directly into action.
Not when a system cannot distinguish between persuasion and authority.
What systems like arifOS try to do is create a small but important gap between:
- language and execution
- confidence and permission
- suggestion and consequence
Inside that gap, better decisions have a chance to happen.
The irony
I’m aware this whole story sounds slightly ridiculous.
A non-coder geologist renting a cheap VPS and thinking about AI governance.
Most of the Python code was written with AI assistance.
I focused on something else.
The boundaries.
The conditions.
The parts where the system must slow down and ask:
- What evidence do we have?
- Who is responsible?
- Is this reversible?
- Should a human approve this?
Those questions are not really programming questions.
They’re governance questions.
And governance problems don’t disappear just because the system sounds intelligent.
The paradox
Part 1 ended with a bold statement.
Maybe I built a kernel.
Now I think the more interesting story might be different.
I didn’t start by trying to build intelligence.
I started by trying to build supervision.
I assumed the adult in the room had to be the human.
But systems are strange things.
If you design the rules carefully enough, the environment itself begins to enforce discipline.
And the behavior inside that environment starts looking… mature.
Which leads to a strange conclusion.
The geologist who built the rules is still very much a child at heart.
But the system he built keeps reminding the machines to behave like adults.
That feels like a paradox.
But then again, geology teaches you something early:
Sometimes the deepest structures are formed under pressure.
And you don’t always see the mark they leave until much later.
Forged, not given.
— Arif Fazil
Geoscientist, Penang
If you want to explore the project
Docs
https://arifos.arif-fazil.com/
Source code
https://github.com/ariffazil/arifosmcp
arifOS runs as a Python package and MCP server that sits between language models and real-world systems.
And yes.
A seven-dollar VPS is apparently enough to teach a geologist what a kernel is.