How a Sovereign Kernel Lets You Govern AI — Without Giving Up Control
by Nato Riley
Imagine deploying any AI model you like, and putting your governance, security and ethical guardrails on top of it so it integrates with your infrastructure and operates like compliant, autonomous software.
I built a special sovereign kernel for AI. Notice I didn't say I built my own AI. My kernel runs any AI technology that I want to integrate into it (it'll even integrate multiple AI's). Not only that, but it specifically sends hardware resources to the AI.
Bored yet?
The kernel's architecture is called a "Super Root" architecture.
Why I made this kernel
Why did I make this kernel and what does it really do?
Before we get into that check out what our tech looks like.
How to start: Cloud Jam Gauntlet
Here's exactly how to start building when you take on the Cloud Jam Gauntlet:
Governing AI with the kernel
This kernel lets me inject governance (GRC), security and ethics into AI functions.
For that matter, this allows me to decide how I want to govern any AI that I use and lets me train a central AI that houses knowledge for multi-agent prompts that use more than one agent.
AI that can be governed and has ethics with technical guard rails means it can be set to run more autonomously as if the human user is its manager and it's your employee.
Most AI models require autonomous functions to be micromanaged.
Our AI models create receipts and don't bar you from using your favorite AI.
Common objections
You might be thinking:
- "Yeah but I like Claude AI better."
- "ChatGPT does everything I need."
- "GRC shouldn't be managed by AI even if it has receipts."
For those wondering why you'd use this over other AI platforms, I will add the reminder and reinforce that we didn't make an AI, so you do need to bring your favorite AI.
So if you like Claude or ChatGPT "better" than what we've built, then there is not an understanding of what we made because we did not make an AI.
Our technology is for control freaks who want more precise AI or folks who want to reduce the risks of letting AI be autonomous.
Learning opportunities
In the screenshot below, you can see it shows "Ollama" and "MCP," which are capabilities living in this agent that allow it to carry out the end user's will.
As you can see, our tech supports these technologies, including MCP technologies — meaning you can improve the quality of your MCP functions with any MCP system as well through understanding how our kernel works.
We will be offering educational opportunities for folks who want to learn how to more effectively govern things in your universe with AI.
For now, feel free to read the AI written story about a tiny doggy with wings who found family with ducks until I drop more info on all this madness we've made.
Here is an example of a story written from my AI experiment in the picture above:
Prompt
You: Tell me a story about a small tiny doggy with wings that made best friends with ducks after being rejected by his pack of tiny doggies. Sorta like the ugly duckling story, but the ugly tiny doggy with wings — give me the story
Doppelganger story
Doppelganger: Once upon a time in a small village, there lived a tiny dog named Ziggy. Ziggy was born with tiny, stubby wings and was immediately rejected by his pack of tiny doggies because of them. They deemed him too different and thought he wouldn't be able to keep up with their lively, adventurous ways.
Feeling alone and left out, Ziggy wandered the village, searching for someone who would accept him for who he truly was. But no one seemed to notice him or care about his wings. Ziggy felt like an outsider, not quite a dog nor quite a bird.
One day, while wandering near a pond, Ziggy spotted a group of ducks swimming gracefully in the water. He watched them closely and was mesmerized by their movements. Suddenly, one of the ducks flew up onto the bank and began to call out to her friends. To Ziggy's surprise, the other ducks swam towards him, quacking happily.
Ziggy couldn't believe it! The ducks had accepted him, despite his wings! They spent hours playing in the water and exploring the nearby woods together. Ziggy was overjoyed to have found a new group of friends who loved and appreciated him for who he truly was.
As time went on, Ziggy's wings began to grow stronger, and he learned how to use them to fly alongside his duck friends. They would soar high above the treetops, taking in the breathtaking views of the surrounding countryside.
The other ducks and animals in the village soon began to notice Ziggy and his new friends, and they too began to accept him for who he truly was. Ziggy no longer felt like an outsider, but rather a beloved member of the community.
And so, Ziggy lived happily ever after with his winged duck friends, enjoying all the adventures that the world had to offer.
Your challenge: Cloud Jam Gauntlet
I dare you to check out my website and take on my Cloud Jam Gauntlet. In the gauntlet, you'll build your own tech with our kernel by deploying a kernel layer.
This is just one step in the gauntlet I've created that will help you sharpen your technical capabilities and critical thinking skills.
I dare you to build something special.
Origins of the kernel
If you want to hear more about the origins of our technology, here are my experiences as a manufacturer that led to me making kernels:
This is an introduction to how we ended up with what became our "Super Root" architecture.
How our team works
To give a sneak peak about some topics in future blogs, the image in the banner of this blog shows how my team works.
As unusual as it sounds, here is my teams workflow:
- Everyone uses what's called a Space-Terrestrial Compute Node (this uses SATCOM combined with 5G to lower costs)
- Everyone gets what's called a Golden Twin that lives across their node and communicates over a central Mission Control Forge that manages everyone's agents as multi-agent interactions
- Before all this AI madness, we custom-coded an artifact mesh network that makes up the back end of the Underground Nexus (with over 10k end-user downloads, more Super Root details can be found on the Underground Nexus GitHub: https://github.com/Underground-Ops/underground-nexus)
- Automations live in the Underground Nexus backend and handle custom-coded roles that run on their own to test and alert our team when there are bugs or security issues to be concerned about
- Any task we do more than once, we eventually add to our Underground Nexus artifact mesh
The Super Root architecture in practice
We build our own appliances with our sovereign kernel. Without me going too deep on the topic just yet, the "Super Root" architecture allows our hardware to be an extension of us as humans. The kernel in the super root forces the host OS (Windows, Mac OS, Linux, etc.) to become its tenant, and our kernel becomes the hardware's "root" (hence Super Root).
Every one of our operational members relies on a Golden Twin (a Digital Twin of it's human user) that helps carry out the will of each user. We also designed Space-Terrestrial Compute Nodes with our sovereign kernel that allow us to always be connected when work needs to get done — whether we are using 5G or satellite to connect to customer ecosystems.
All of our Golden Twin systems talk back to a central Mission Control Forge core that is a central intelligence all field twins work with. This then allows our central intelligence to drive our company as a flywheel model.
Flywheel model and self-driving businesses
This is a topic for another day, but you may do your own research about what a flywheel business model is (Amazon's maybe the most well known flywheel business out there).
Our Golden Twins are designed to turn manual labor into flywheel systems — the benefit is your company becomes more and more passive as the years go by until you have a self-driving business.
We tested making notiaPoint — a self-driving business — to make this real, which is also a topic for another day.
We love GRC and DevSecOps (aka continuous security) because you can't build self-driving businesses without GRC and continuous security.
What’s next
Now that I've talked about the kernel itself that makes up the foundation of how we ended up with the Super Root, in my next blog I'll continue talking about the kernel's architecture itself.
Most importantly...
I dare you to build something special.
Ready to sharpen your infrastructure muscle and prove you can build compliant, sovereign systems? Take on the Cloud Jam Gauntlet now and show what you’re made of.
