IONA OS is an operating system written from scratch in Rust. It has its own kernel, its own GUI, its own blockchain protocol, its own programming language (Flux), and — since recently — its own kernel-integrated AI.

Not a chatbot. Not a cloud API wrapper. An AI that runs in Ring 0, reads CPU temperature directly, kills processes, synthesises drivers, and optimises the system in real time.

The hardest part wasn't making it work. The hardest part was making it trustworthy. When an AI runs inside the kernel, a hallucination isn't just a wrong answer — it could crash the system, corrupt memory, or make a bad decision that leaves your laptop unusable.

Here's how we built IONA AI to be reliable, self-correcting, and causally aware.

1 Detecting Hallucinations Before They Happen
Most AI systems generate text and hope it's correct. IONA AI cross-checks facts.

When the AI says "CPU is over 80°C", the system doesn't just accept it. It verifies the correlation with power draw in watts. We maintain a watts anchor and check consistency. If CPU temperature is high but power draw is low, the system knows something is wrong. It logs the anomaly and overrides the response.

This cross-fact consistency prevents the AI from confidently stating false information.

1. Causal Chains — Not Just Correlations The AI doesn't just say "CPU is hot". It says why.

We built a causal chain module that records every event with a parent pointer. When the AI observes a problem, it traverses the chain backwards and builds a narrative: temperature rose because governor was set to Performance when you compiled the kernel, which spawned eight threads that consumed ninety-five percent CPU for four minutes.

This is more than logging. It is causal reasoning.

1. Cycle Detection — No Infinite Loops in Logic When an AI reasons about itself, it can fall into circular logic: A caused B, B caused C, C caused A.

We added explicit cycle detection in the causal chain explain function. If a cycle is found, the AI reports it clearly: "Causal cycle detected: thermal_throttle → governor_change → cpu_load → thermal_throttle."

This prevents the AI from getting stuck in self-referential reasoning and forces it to break the loop by suggesting an external action.

1. Memory with Decay — But Not All Facts Are Equal We store facts in a knowledge graph with a confidence score. High-confidence facts above 0.85 decay two times slower than low-confidence ones.

A fact like "CPU governor is Performance" with confidence 0.98 decays at a slower rate, while "User likes dark theme" with confidence 0.60 decays faster.

This keeps the system from forgetting what it really knows while allowing uncertain information to fade.

1. Adaptive Backoff — Don't Reason When the System is Dying When CPU load exceeds eighty percent, the AI stops expensive reasoning like multi-agent debate or deep chain-of-thought and switches to lightweight mode.

If CPU usage is high, reasoning depth is reduced to one. If the system is idle, reasoning depth goes back to three.

This ensures the AI doesn't make the system worse when it is already struggling.

1. Energy Optimizer that Learns from Reality The AI tracks which energy policies actually save power and reorders them based on real-world results.

Policy A saved twelve watts and is ranked first. Policy B saved four watts and is ranked second. Policy C saved one watt and is ranked third.

At tick two hundred, the system re-ranks policies by watts saved per applications affected. It learns from its own actions.

1. Parliament → Long-Term Memory Every AI decision that goes through the governance system, which we call the parliament, is persisted to episodic memory. The AI remembers not just what was decided, but who voted, why, and what the outcome was.

This allows the system to learn from past deliberations and improve future decisions.

1. Topics Beyond Chat
   We extended the dialog topic detector from five to eight topics, adding network, storage, and AI. The AI now maintains separate conversation contexts for each, so it doesn't confuse a discussion about storage with one about security.

2. Goal Tracker with Real Metrics
   The AI can track user-defined goals, but now it evaluates them using real system data.

For example, a goal like "keep power under thirty-five watts" is evaluated against actual power draw. If current power is twenty-eight watts, progress is shown as fifty percent.

Custom goals are no longer empty promises. They are actual dashboards.

1. User Model + Process Intelligence The AI now understands what the user is doing by reading process lists. It classifies workloads as compilation, editing, browsing, or idle and adjusts its behaviour accordingly.

If the system detects compilation, it switches the governor to Performance. If it detects idle, it switches to Powersave.

No user interaction is required. The system just knows.

Building an AI that runs inside the kernel is hard. Building one that can be trusted — that doesn't hallucinate, doesn't spiral into circular reasoning, and doesn't crash the system — is even harder.

IONA AI is still evolving. But with these ten additions, it is no longer just a chatbot. It is a self-correcting, causally aware, energy-optimising agent that lives inside the operating system itself.

All sixty-three thousand lines of it, in Rust, running in Ring 0.

The code is not yet fully public, but you can see the architecture on GitHub. IONA OS launches on September 15, 2026. The website is iona.zone.