Only OS: Deterministic Runtime Governance via Arithmetic Equilibrium

The Core Idea

Conventional software treats validity as boolean logic: true or false, valid or invalid. Only OS treats validity as balance. If a value corrupts or a proposed action breaks equilibrium, the system detects the imbalance and either solves/heals the missing value or denies execution.

This is not a rule engine. It is an arithmetic law layer.

The Three-Plane Architecture

COGNITIVE PLANE (LLM / Agent Swarm)
- Reasons, summarizes, proposes actions
- Has zero direct execution privilege
        ↓ proposal + justification
AUTHORITY PLANE (Only OS / Only-Lang Gateway)
- Parses the action structurally
- Evaluates deterministic constraints
- Issues signed short-lived capability tokens
        ↓ cryptographic token
EXECUTION PLANE (Secure Tools)
- Databases, APIs, ledgers, infrastructure
- Rejects unsigned or invalid tool calls

The cognitive plane (the AI) has zero direct execution privilege. It can only propose actions. The authority plane (Only OS) evaluates proposals against arithmetic constraints and issues signed capability tokens. The execution plane only accepts signed, valid tokens.

Workspace Members

The Only Engine workspace contains:

Crate	Purpose
only-core	PIR signs and equilibrium checks. The arithmetic law layer.
only-evolution	Solver/healer that recalculates missing/corrupted values to restore equilibrium.
only-memory	Ghost memory encoders using balanced fields and higher-order moments.
only-lang	DSL/evidence/governance tooling for constraints and harmonies.
only-lang-wasm	WASM bridge for browser/JS usage.
boot-sim	Boot simulation showing corruption detection and arithmetic self-healing.
fpga-pir-bridge	Hardware/FPGA-oriented bridge for PIR signs/residuals.

How Equilibrium Governance Works

only-core: The Law Layer

only-core implements PIR signs and equilibrium checks. Every value in the system has an arithmetic signature. When a value is corrupted, its signature breaks equilibrium — the system detects this immediately.

only-evolution: The Healer

When corruption is detected, only-evolution attempts to restore equilibrium. It recalculates missing or corrupted values from the surrounding arithmetic context. This is self-healing: the system fixes itself without external intervention.

only-lang: The Constraint Language

only-lang is a DSL for defining constraints and harmonies. Developers write rules in only-lang that specify what equilibrium means for their domain. The language supports evidence manifests — structured proofs that a proposed action satisfies all constraints.

only-memory: Ghost Memory

only-memory uses balanced fields and higher-order moments to encode and recover data. This is Ghost Storage — data hiding and recovery via arithmetic structure, not encryption alone.

Self-Healing in Practice

The boot-sim demonstrates the system:

1. A value is corrupted (simulated bit flip)
2. only-core detects the equilibrium break
3. only-evolution recalculates the correct value from context
4. The system continues running — no crash, no data loss

This is arithmetic self-healing. The system does not just detect corruption — it fixes it.

Why This Matters

Current AI governance relies on monitoring: watch what the AI does, flag bad behavior, hope to catch it in time. Only OS takes a different approach:

• Before execution: The authority plane checks arithmetic equilibrium. If the proposal breaks balance, execution is denied.
• During execution: Signed capability tokens ensure only approved actions reach the execution plane.
• After corruption: Self-healing restores equilibrium without external intervention.

This is deterministic governance — not probabilistic monitoring. The math either balances or it doesn't. There is no "maybe."