The GuardOS Review · Vol. I · No. 1
An open dispatch on personal computing & defense
— A field report from the edge of trust —

GuardOS

An AI-armored personal operating system that defends a single device across every layer — from firmware to human behavior.

Open Source · GPL-3.0 · Local-First AI

A castle with seven walls

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.

Security is not a product — it is a practice. And practice begins by refusing the lie that one wall is enough. — GuardOS Core Principles

The Onion, in detail

Seven layers. Each with its own gatekeeper, its own telemetry, its own containment. A breach must cross every wall to reach the next.

L6 · Human L5 · Identity L4 · Network L3 · Apps L2 · OS L1 · Kernel L0 FIRMWARE
L0Firmware & Hardware — Coreboot or Heads where possible. Measured boot. TPM-anchored attestation. The root of every trust decision above.
L1Kernel & Drivers — Hardened Linux with lockdown mode, AppArmor + Landlock, signed module loading. The brainstem.
L2Operating System — Immutable, declarative, atomically rollbackable. If malware writes to the system, you reboot the wound away.
L3Applications — Flatpak sandboxes by default; micro-VMs for high-risk formats. PDFs and Office files open in SafeView, with no network, no execution.
L4Network & Interfaces — Per-app eBPF firewall, USBGuard quarantine on insertion, encrypted DNS, optional WireGuard egress.
L5Identity & Credentials — Passkeys, FIDO2, TPM-sealed LUKS. No plaintext secrets. No biometric fallbacks that can be coerced.
L6Human Behavior — Aegis, the local AI advisor: explains risk in plain English, classifies phishing, flags beaconing. The user is part of the trust base, given superpowers.

Aegis: an AI that does not phone home

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.

What you actually get

A handful of concrete tools, each contained, each explainable, each replaceable.

No. 01

Immutable base

NixOS-style declarative system with A/B atomic updates and signed generations. If an update breaks anything, the previous generation is one reboot away.

No. 02

SafeView

Untrusted PDFs, images, and Office files open in a rasterized, networkless sandbox. Macros never execute. Trackers never load. The file stays where it is.

No. 03

Hunter Mode

An opt-in defensive trap layer: canary files, decoy credentials, sinkholed DNS, ring-buffer packet capture. Useful when you suspect you are already compromised.

No. 04

Per-app egress

An eBPF/XDP firewall enforces allowlists at the application layer. Your browser may speak to the world; your PDF reader may not.

No. 05

USB quarantine

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.

No. 06

TPM-sealed identity

LUKS volumes unlocked by hardware-bound keys. Passkeys and FIDO2 instead of passwords. Secrets that cannot leave the silicon they were sealed to.

In the company of giants

GuardOS shares its spirit with Qubes, Tails, and GrapheneOS — and differs in three meaningful ways.

Capability GuardOS Qubes OS Tails GrapheneOS
Target deviceDesktop / laptopDesktop / laptopLive USBMobile (Pixel)
Immutable base + rollbackYesTemplatesAmnesicYes
Verified boot & TPMYes (Heads)YesNoNo
App sandboxingFlatpak + micro-VMPer-VMLimitedPer-app SELinux
Local AI advisorYes (Aegis)NoNoNo
Performance costModerateHighLowLow
Beginner friendlyImprovingSteepYesYes

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.

What you can run it on

Reference devices are chosen for openness — flashable firmware, available TPM, audited drivers — not for novelty.

Tier I — flagship

Best supported

  • ThinkPad X230 (Coreboot/Heads, TPM 1.2)
  • ThinkPad T480 (TPM 2.0, modern specs)
  • Framework 13 / 16
  • Librem 14
  • MinisForum UM790
Tier II — capable

Works well

  • ThinkPad T420, T430, X270
  • HP EliteBook 820 G2, 2170p
  • Most 2018+ Intel/AMD with TPM 2.0
Beta — experimental

Use with caution

  • Pinebook Pro (ARM64)
  • RockPro64
  • RPi 4 / 5 (limited AI)
Not recommended

Avoid

  • MacBooks with T2 chips
  • Locked Chromebooks
  • Modern X1 Carbon (locked ME)
  • Android tablets

Where the project actually is

A pre-alpha shell prototype, with a credible path to a bootable v1.0 — and a community-led pace.

v0.1 — done

Conceptual base

Onion model published, Aegis policies drafted, profiles and validators working, hardware shortlist confirmed.

v0.2 — in progress

Developer kickstart

Starter Nix flake, Flatpak sandbox baseline, contributor onboarding docs, build helpers for ISO and QEMU.

v0.3 — next

QEMU pre-alpha boot

Boots to a guarded desktop in QEMU. Egress-first network presets. First Aegis watchdog shell.

v0.4 — alpha

Reference hardware

Boots on X230 and T480. TPM-sealed LUKS. USB quarantine. Per-app firewall live.

v1.0 — MVP

Bootable & working

Public ISO, signed checksums, hardened defaults, plain-language docs. Daily-driver capable on two reference laptops.

// ORIGIN — GENESYS.md

An idea, in transcript

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.