Cybou — Technical Blueprint & Architecture

1. Executive Summary & Core Vision

Cybou is an experimental agent-native operating environment with independently testable layers: a reproducible system foundation, Mind — a local typed runtime for durable biography, identity, commitments, prediction, bounded attention, health and recovery — and a replaceable Rust/WebAssembly interface. It is not a chatbot and makes no claim of consciousness.

Layer 1: Reproducible Body

Locked Flakes, atomic generations, VM/ISO/Hyper-V outputs, and explicit build and recovery gates. Debian 13 is the active build and verification environment for every Linux gate.

Layer 2: Typed Mind Runtime

Twelve isolated systemd user services communicate through typed D-Bus contracts. Event1 is the canonical Journal boundary; Presence is a projection, not a second owner. Language models and privileged execution remain absent.

Layer 3: Replaceable Interface

A Rust workspace carries the protocol, fabric codec, runtime and storage paths, and web contracts. A read-only gateway on loopback projects Presence into typed JSON and a bounded event stream, and Living Canvas renders it as WebAssembly in a browser or desktop shell.

2. Architecture & Technical Stack

Cybou separates Body, Mind, and Presence. Durable state belongs to explicit owners; every surface is a cache and presentation boundary. Cross-owner commands are bounded and fail closed.

Core System Stack

Base System: NixOS 26.05 locked via Nix Flakes; Debian 13 is the active build and verification host for Linux gates.
Rust Workspace: One locked Cargo workspace holding the protocol and fabric codec, runtime and storage paths, replacement organ slices, web contracts, the read-only gateway, and the Living Canvas WebAssembly frontend.
Delivery: The gateway binds to loopback, serves the content-hashed frontend from its own origin, and exposes typed session, snapshot, and bounded event-stream routes with no mutation route.
Session: An opt-in Wayland session gives the frontend a single surface through a minimal compositor and an ephemeral browser runtime profile. The KDE/Qt shell remains migration-era code and the current fallback.
Theme & Aesthetics: Cybou Horizon global theme, dark/light color tokens, and one coherent visual grammar across login, windows, and wallpaper.
Build Output: Bootable NixOS ISO, qemu/KVM virtual machine targets, and Hyper-V development images.
Mind Runtime: Twelve C++20/Qt 6 user services activated by systemd and addressed through typed D-Bus interfaces.
Canonical Memory: One event daemon is the only Journal writer; Journal v3 preserves causal metadata verification while supporting crash-safe payload erasure.
Continuity: Identity, intentions, lifecycle runs, health snapshots, and event consumer progress persist under versioned schemas and atomic writes.
Failure Model: Optional-owner loss degrades only dependent capabilities; required-owner loss fails mutations closed without inventing state.

Process and ownership topology

Living Canvas (Rust / WebAssembly)
            │ typed JSON + event stream
            ▼
   cybou-web-gateway (read-only, loopback)
            │ Presence1
            ▼
      cybou-presenced
       ├─ Identity1   → cybou-identityd
       ├─ Intention1  → cybou-intentiond
       ├─ Predictor1  → cybou-predictord
       ├─ Self1       → cybou-selfd
       ├─ Workspace1  → cybou-workspaced
       ├─ Lifecycle1  → cybou-lifecycled
       ├─ Health1     → cybou-healthd
       ├─ Perception  → cybou-perceptiond
       ├─ Epistemics  → cybou-epistemicd
       ├─ Context     → cybou-contextd
       └─ Event1      → cybou-eventd → SQLite Journal v3

3. Cognitive Contracts and Safety Boundaries

The implemented substrate keeps cognition inspectable without turning a model, UI, or coordinator into an unbounded owner. Future capabilities must preserve these contracts:

Ownership before intelligence: model ≠ identity, UI ≠ Mind, attention ≠ biography, and proposal ≠ authorization.
Durability before visibility: state is projected only after its owner commits it; consolidation adds evidence-linked outcomes and never rewrites history.
Bounded degradation: Health1 publishes typed deficits and recovery progress; compound reads and mutations share one monotonic deadline.
No hidden agency: the interface may only read; M8 language is optional and replaceable, and M9 learning, M10 action, and M11 agents remain separate governed boundaries.

4. Implementation Status & Progress Matrix

Development progress is tracked rigorously across milestone phases and verified against automated acceptance gates.

Milestone	Status	Capability	Implemented boundary	Primary evidence
M0	DONE	Green reproducible baseline	Locked flake, formatting, licensing, metadata, documentation and UI gates	Reproducible flake checks and focused gates
M1–M4	DONE	Accepted memory and isolated organs	Single Event1 writer, isolated services, remote Presence proxy	Protocol, process, event, UI API and VM tests
M5	DONE	Continuity and consolidation lifecycle	Persistent run state, Lifecycle1, deterministic owner effects, restart and reboot recovery	Lifecycle continuity and split-commit fault gates
M6 / P6.1–P6.6	DONE	Health, scheduling and recovery	Capability graph, Health1, homeostasis v2, evidence-bound scheduling, degraded UI contract	Recovery boundary and process fault matrix
P6.7	DONE	Bounded Presence orchestration	One monotonic budget for every compound Presence read and mutation	Bounded RPC, suspended-owner process tests and KVM continuity
M7	IN PROGRESS	Grounded cognition and governed context	Perception, epistemics, Journal v3 erasure, sensitivity, associative projection, and governed delivery	Focused unit, process, scale, retention and disclosure gates
W0–W1	DONE	Rust foundation and read-only web boundary	Locked Cargo workspace, protocol, fabric, runtime and web-contract crates, loopback gateway with typed session, snapshot, and resumable event stream	Native tests, strict lints, WebAssembly build and release frontend gates
W2	IN PROGRESS	One interface for browser and desktop shell	Shared WebAssembly frontend, independently buildable shell derivation, opt-in single-surface session	Bootstrap authentication, lock screen, multi-display, input method, and accessibility gates remain open
M8	PLANNED	Optional language faculty	Replaceable model behind typed context and proposal contracts	No model is shipped today
M9–M13	PLANNED	Learning, governed action, agents and security	Learned artifacts, authorization, execution, agents, tools, and security remain separate governed boundaries	None of these future runtimes is shipped today

5. Security, Privacy & Licensing

Cybou is free software built for sovereignty and privacy:

Code License: MIT License for all Nix code, build scripts, Rust crates, web assets, and core logic.
Visual Assets: Creative Commons Attribution-ShareAlike 4.0 for logos, wallpapers, and desktop themes.
Trust Boundaries: Same-user local IPC is not treated as a complete capability-security boundary; future privileged action requires a separate authorization layer.
Interface Boundary: The web gateway binds to loopback only, is read-only by construction, and applies no-store and browser-security headers. Bootstrap authentication is not yet implemented, so no live cognitive state may be exposed beyond the local device.
Privacy: Event envelopes carry explicit privacy and sensitivity axes. Crash-safe transitive erasure and governed disclosure are implemented; sensitive payload storage, automatic expiry, backups, and replication remain open.
Current Cloud Boundary: The runtime and interface require no hosted AI service or API key, and no language model is shipped today.
Security Documents: The repository maintains explicit threat and privacy models under version control.

Canonical sources and claim authority

This web whitepaper is a readable summary. Exact implementation claims are governed by the repository:

Current State — authoritative implemented boundary.
Architecture and Mind Model — topology, ownership, and long-term model.
Testing — process, reboot, fault, and KVM evidence.
Next Engineering Steps — detailed implementation record and current work.

6. Frequently Asked Questions

Cybou is an experimental agent-native operating environment. A persistent local runtime called Mind owns durable memory, identity, commitments, lifecycle, health, and evidence, while models, agents, tools, and user interfaces stay replaceable around it.

A model is not Mind. An agent is not Mind. A tool protocol is not an authorization boundary. Cybou makes memory, identity, health, lifecycle, and recovery explicit system services with named owners, so no model can become the owner of continuity or authority.

No. The current runtime and interface need no cloud account, API key, or hosted AI service, and Cybou implements no telemetry. Remote models may become available later, but only behind explicit context, sensitivity, egress, and cost policy.

One Rust/WebAssembly frontend called Living Canvas serves both an ordinary browser and a lightweight desktop web shell. It reads through a read-only Rust gateway bound to loopback that exposes typed session, snapshot, and event streams and has no mutation route. The earlier KDE/Qt shell is migration-era code, not the target.

Cybou ships no language model, no agent or worker runtime, no model or tool broker, no privileged action executor, and no autonomous security control plane. Desktop bootstrap authentication is also still open. These are planned boundaries and are never described as done.