An AI-armored personal operating system that defends a single device across every layer — from firmware to human behavior.
Modern attacks do not respect perimeters. They move from a poisoned PDF to the kernel to the firmware in a single afternoon. GuardOS asks: what if every layer defended itself?
The dominant model of personal-computer security is, when examined honestly, a thin wall around an open courtyard. A firewall here, an antivirus there, a vague hope that the user will not click. Once that wall is breached — by a phishing email, a poisoned download, a malicious USB stick — the attacker enjoys the run of the place: applications, files, network sessions, sometimes the kernel, occasionally the firmware itself.
GuardOS proposes a different shape. Imagine the device not as a courtyard but as an onion: seven concentric layers of defense, each verifying the layer beneath it and constraining the layer above. A breach in one is contained by the next. There is no single wall to fail.
It is, at its heart, a simple architectural commitment: treat every layer as suspect, and have every layer prove itself. Built on hardened open-source foundations — a NixOS-style immutable base, Coreboot-friendly firmware, Flatpak-sandboxed applications, an eBPF firewall, TPM-sealed identity — and tied together by a local AI advisor that explains risk in plain English without phoning home.
Seven layers. Each with its own gatekeeper, its own telemetry, its own containment. A breach must cross every wall to reach the next.
The seventh layer of the onion is the user — and traditional security has been almost cruel about it. Pop-ups asking, in technical jargon, whether to allow a certificate. Dialog boxes that punish curiosity. The user, by design, is the weakest link.
GuardOS treats the user as part of the trusted computing base, and equips them accordingly. Aegis is a quantized LLM that runs entirely on-device. No API keys. No remote inference. No telemetry, by default. It watches the audit bus — process events, USB insertions, outbound DNS, file integrity — and turns alerts into sentences a human can act on.
“This PDF was downloaded from a domain first seen two hours ago and contains macros. Open in SafeView, or quarantine?” That is Aegis. The model itself never leaves the device, and the data it sees never leaves either.
Three policies govern its behavior, all written as plain YAML in ai/policies/: a safety policy, a tool-rules policy, and a per-profile mode that defaults to local-only with all network paths denied. Hybrid and cloud modes exist as future options, gated behind explicit user consent and a planned encrypted Guard-Tunnel — never as defaults.
A handful of concrete tools, each contained, each explainable, each replaceable.
NixOS-style declarative system with A/B atomic updates and signed generations. If an update breaks anything, the previous generation is one reboot away.
Untrusted PDFs, images, and Office files open in a rasterized, networkless sandbox. Macros never execute. Trackers never load. The file stays where it is.
An opt-in defensive trap layer: canary files, decoy credentials, sinkholed DNS, ring-buffer packet capture. Useful when you suspect you are already compromised.
An eBPF/XDP firewall enforces allowlists at the application layer. Your browser may speak to the world; your PDF reader may not.
Newly inserted devices are blocked by default. A keyboard claiming to be a keyboard must justify itself before the kernel grants it the right to type.
LUKS volumes unlocked by hardware-bound keys. Passkeys and FIDO2 instead of passwords. Secrets that cannot leave the silicon they were sealed to.
GuardOS shares its spirit with Qubes, Tails, and GrapheneOS — and differs in three meaningful ways.
| Capability | GuardOS | Qubes OS | Tails | GrapheneOS |
|---|---|---|---|---|
| Target device | Desktop / laptop | Desktop / laptop | Live USB | Mobile (Pixel) |
| Immutable base + rollback | Yes | Templates | Amnesic | Yes |
| Verified boot & TPM | Yes (Heads) | Yes | No | No |
| App sandboxing | Flatpak + micro-VM | Per-VM | Limited | Per-app SELinux |
| Local AI advisor | Yes (Aegis) | No | No | No |
| Performance cost | Moderate | High | Low | Low |
| Beginner friendly | Improving | Steep | Yes | Yes |
No system today combines an immutable base, hardware-anchored boot, layered sandboxing, and an explainable on-device AI. That is the gap GuardOS aims to fill.
Reference devices are chosen for openness — flashable firmware, available TPM, audited drivers — not for novelty.
A pre-alpha shell prototype, with a credible path to a bootable v1.0 — and a community-led pace.
Onion model published, Aegis policies drafted, profiles and validators working, hardware shortlist confirmed.
Starter Nix flake, Flatpak sandbox baseline, contributor onboarding docs, build helpers for ISO and QEMU.
Boots to a guarded desktop in QEMU. Egress-first network presets. First Aegis watchdog shell.
Boots on X230 and T480. TPM-sealed LUKS. USB quarantine. Per-app firewall live.
Public ISO, signed checksums, hardened defaults, plain-language docs. Daily-driver capable on two reference laptops.
GuardOS began as a conversation. A non-technical question — “if a computer is an onion, what are its layers?” — that grew, over many afternoons, into an architecture, a threat model, a hardware matrix, and a roadmap. The full literal transcript, with personal information removed, is preserved in the repository as GENESYS.md: not as marketing, but as receipts. Anyone who wants to know how GuardOS arrived at its claims is invited to read the whole exchange.
The codebase is small and shell-first by design. The policies are YAML you can read in five minutes. The diagrams are SVG, the prose is Markdown, the license is GPL-3.0. There are no hidden services, no closed components, no required cloud. If you can read a configuration file, you can audit GuardOS.