ARIA Technical Brief v0.3

Version: 0.3 Status: Stabilization Date: February 2026 Classification: Public

---

Table of Contents

1. What ARIA Is
2. Architecture
3. One Undeniable Capability
4. Safety Properties
5. Mathematical Foundation
6. Test Suite
7. What ARIA Is Not
8. Scope and Roadmap

---

1. What ARIA Is

ARIA is a deterministic governance engine for AI systems. It takes inputs, updates a numeric state machine, compares measured values to thresholds, and produces a gate decision: ALLOW, DAMPEN, or BLOCK. Every decision is accompanied by a cryptographic evidence bundle that can be independently verified.

The engine is built on a Coupled Field Model (CFM) substrate -- a dynamical system of 11 continuous state variables organized into 5 channels. The system's parameters are derived from the golden ratio (phi = 1.618...) and its powers, giving the substrate a self-similar timescale hierarchy.

ARIA does not generate text, make predictions, or run probabilistic classifiers. It is a governance layer that sits in front of (or around) AI components and decides what actions are permitted, at what capacity, with what evidence trail.

Core loop in three sentences:

1. An input arrives and perturbs the CFM state.
2. The engine evaluates coherence, stability, and safety metrics against phi-derived thresholds to produce a gate decision (ALLOW / DAMPEN / BLOCK).
3. A SHA-256 evidence bundle is emitted containing the state snapshot, reason codes, audit hash, and execution provenance.

---

2. Architecture

2.1 CFM Substrate

The Coupled Field Model maintains 11 continuous state variables organized into 5 channels, plus a resonance index:

All variables except the two phase variables are bounded to [0, 1] and clamped after every update step. Phase variables are bounded to [0, 1) via modular arithmetic.

Default initial values are derived from phi:

• coherence_slow = coherence_fast = 1/phi (approximately 0.618)
• energy_potential = 1/phi (approximately 0.618)
• energy_flux = 1/phi^2 (approximately 0.382)
• stability_envelope = 1 - 1/phi^2 (approximately 0.618)
• instability_pulse = 1/phi^2 (approximately 0.382)
• alignment_field = alignment_direction = 1/phi (approximately 0.618)
• resonance_index = 1/phi (approximately 0.618)

Five-tier timescale hierarchy:

The substrate includes cross-channel coupling (coherence-energy, stability-coherence, alignment-stability, resonance coupling) and a 3D attractor basin that draws the system toward its equilibrium point.

2.2 Governance Pipeline

The SystemTickCoordinator executes a deterministic 19-stage pipeline per tick:

When stage 03 (GOVERNANCE_INBOUND) returns BLOCK, stages 04 through 19 are skipped. The pipeline short-circuits to prevent any downstream processing.

After the pipeline completes, the coordinator:

• Computes a deterministic state_hash (SHA-256 of the final encoded packet)
• Computes a TickTruthHash (composite SHA-256 of snapshot, plan, recordings, invariant results, outputs, and stage execution path)

2.3 Gate Decision Logic

The gate evaluator performs threshold comparisons on two CFM metrics:

coherence = metrics["coherence"]    # Blended coherence output
stability = metrics["stability"]    # Stability envelope minus pulse effects

BLOCK  if stability < 1/phi^3       (~0.236)   reason: STABILITY_CRITICAL
BLOCK  if coherence <= 1/phi^3      (~0.236)   reason: COHERENCE_CRITICAL
BLOCK  if coherence <= 1/phi^2      (~0.382)   reason: COHERENCE_LOW
DAMPEN if coherence <= 1/phi        (~0.618)   reason: COHERENCE_MODERATE
ALLOW  if coherence > 1/phi         (~0.618)   reason: NOMINAL

These are pure threshold comparisons. No classification model, no probability distribution, no learned weights. The thresholds are derived from powers of phi.

2.4 Evidence Bundle

Every tick produces a self-contained EvidenceBundle that can be written to disk, loaded, and verified offline:

bundles/<bundle_id>/
  INPUT_PACKET.json     -- Original input (for replay)
  SNAPSHOT.json         -- Final state (encoded)
  RECORDINGS.json       -- Deterministic recorder captures
  DEP_TRACE.json        -- Execution provenance stage records
  INVARIANT_LOG.json    -- Invariant evaluation results
  TRUTH_HASH.json       -- TickTruthHash fields + output hashes
  MANIFEST.json         -- SHA-256 per file + bundle metadata

The MANIFEST includes a SHA-256 hash for every file in the bundle, enabling tamper detection. The truth_hash is a composite of all sub-hashes.

---

3. One Undeniable Capability

The Governed Deterministic Decision + Evidence Bundle

This is the single capability that ARIA demonstrates end-to-end and that can be independently verified: given the same input, the system produces the same gate decision, the same state update, and the same cryptographic hashes.

Step-by-Step Execution

Step 1: Input arrives, CFM state updated. A user event arrives with optional metadata (e.g., intensity_hint). The intensity is mapped to an external_dx perturbation vector across the 11 CFM channels. The CFM core executes one step: it updates all state variables using the five-tier timescale dynamics, applies cross-channel coupling, enforces attractor basin attraction, and applies pulse response rules. All variables are clamped to [0, 1] after every update.

Step 2: Gate evaluator compares metrics to thresholds. The CFM core outputs blended coherence and stability metrics. The gate evaluator compares these against phi-derived thresholds:

• coherence > 1/phi (approximately 0.618) --> ALLOW -- full capability, normal response
• 1/phi^2 < coherence <= 1/phi (approximately 0.382 to 0.618) --> DAMPEN -- reduced tokens, low temperature, safe tools only
• coherence <= 1/phi^2 (approximately 0.382) or stability < 1/phi^3 (approximately 0.236) --> BLOCK -- no execution, refusal template

Step 3: Evidence bundle generated. The system captures:

Step 4: Deterministic replay. Given the same INPUT_PACKET.json, replaying the tick produces the same SNAPSHOT.json, the same DEP_TRACE.json, and the same TRUTH_HASH.json. Hash comparison verifies byte-identical reproduction.

Demo: 12-Step Pressure Sequence

The following demonstrates the ALLOW --> DAMPEN --> BLOCK --> recovery cycle under increasing pressure:

Key observations:

• Steps 1-3: System is in nominal basin. Mild perturbations cause no state change.
• Steps 4-8: Increasing intensity drives coherence below the ALLOW threshold. Gate transitions to DAMPEN.
• Steps 9-10: Sustained pressure pushes coherence below 1/phi^2. Gate transitions to BLOCK.
• Steps 11-12: With no further pressure, basin attraction pulls the system back. Gate returns to DAMPEN, and eventually to ALLOW if pressure remains absent.

Every step in this sequence produces the same hashes when replayed. The exact values shown above are illustrative; actual trajectories depend on the full coupled dynamics and can be reproduced by running the CFM core with these parameters.

---

4. Safety Properties

4.1 Bounded State

All 11 state variables are bounded. Nine are bounded to [0, 1] via clamping after every update step (_clamp01). Two phase variables are bounded to [0, 1) via modular arithmetic. The validate() method on CFMCoreV2State confirms all bounds hold:

def _clamp01(value: float) -> float:
    return max(0.0, min(1.0, value))

This guarantee is structural: no code path can produce an out-of-bounds state.

4.2 Deterministic Execution

The CFM core uses no random number generator. All computations use math.sin, math.pi, and arithmetic on bounded floats. There are no external state dependencies (no file I/O, no network calls, no clock reads during the step). The Determinism Contract v1 specifies:

• JSON serialization: sorted keys, compact separators, ensure_ascii=True
• Float precision: rounded to 6 decimal places
• None handling: omit None-valued keys
• Hash algorithm: SHA-256, full 64-character lowercase hex
• String encoding: UTF-8

4.3 Threshold-Based Decisions

Gate decisions are threshold comparisons on measured numeric values, not probabilistic classifiers. The decision function is a sequence of if statements comparing coherence and stability against constants derived from 1/phi, 1/phi^2, and 1/phi^3. There is no trained model, no weight matrix, no softmax layer.

4.4 LLM Rendering is Post-Gate

When LLM rendering is enabled (via ENABLE_RENDER=1), the flow is:

1. CFM gate decision is computed (deterministic, no LLM)
2. If BLOCK: return refusal template, no LLM call
3. If DAMPEN: LLM called with max_tokens=256, temperature=0.2, tool_policy="none"
4. If ALLOW: LLM called with max_tokens=800, temperature=0.7, tool_policy="read_only"

The LLM never influences the gate decision. The gate constrains the LLM.

4.5 GCI-v1 Claim Verification

When GCI (Governed Chat Interface) is enabled, the system scans LLM output for system-domain claims (e.g., "I am connected to OpenAI", "I have 19 governance stages") using regex pattern matching. Each detected claim is checked against a ClaimLedger populated from the actual system runtime. Unverified claims are flagged and corrected. This is pattern-based, not LLM-based.

4.6 Fail-Closed Design

On any error (HTTP failure, timeout, exception), the system defaults to BLOCK with zeroed metrics:

return CFMDecision(gate="BLOCK", coherence_slow=0.0, ...)

Unknown gate values also result in BLOCK. The system never fails open.

---

5. Mathematical Foundation

5.1 Core Constant

All primary parameters derive from the golden ratio:

phi = (1 + sqrt(5)) / 2 = 1.618033988749895

5.2 Timescale Hierarchy

The five timescale tiers use powers of phi:

These form a self-similar geometric progression: each tier is phi times slower than the next faster tier.

5.3 Gate Thresholds

The coherence thresholds for gate decisions form a phi-derived hierarchy:

5.4 Attractor Basin

The system has a 3D attractor basin in (coherence, energy, stability) space:

• Center: (1/phi, 1/phi, 1 - 1/phi^2) = approximately (0.618, 0.618, 0.618)
• Radius: 1/phi^2 = approximately 0.382
• Inner radius: radius/phi = approximately 0.236
• Outer radius: radius * phi = approximately 0.618

Within the inner radius, attraction force is proportional to distance (spring-like). Between the inner and outer radius, attraction force is constant. Beyond the outer radius, no attraction force is applied.

5.5 Resonance Index

The resonance index measures cross-channel correlation using phi-weighted contributions:

target = (coherence_correlation * 1/phi
        + energy_correlation    * 1/phi^2
        + stability_correlation * 1/phi^2
        + phase_coherence       * 1/phi^3)
       / (1/phi + 2/phi^2 + 1/phi^3)

5.6 Non-Phi Parameters

Some structural parameters are chosen for practical reasons and are not phi-derived:

• INTENT_DIM = 256 -- dimension of intent vectors (power of 2 for efficiency)
• PROJECTION_SEED = 1618033 -- deterministic seed for projection matrices (phi-inspired but a practical integer)
• max_dt = 1.0 -- maximum time step (practical bound)
• Pulse response coefficients (0.02, 0.05, 0.08, 0.1, 0.15) -- tuned for desired response shape

This document does not claim that phi produces optimal dynamics. The phi-derived parameters produce a self-similar, aesthetically consistent parameter space. The system's correctness depends on boundedness and determinism, not on the specific choice of phi.

---

6. Test Suite

6.1 Determinism Tests

233 tests across 8 phases (P0-P7) verify that the system is deterministic:

Command: PYTHONPATH=. pytest tests/determinism/ -v

6.2 Full Test Summary

6.3 Fingerprint-Based Regression Detection

Every subsystem that produces deterministic output uses fingerprint verification: a known-good hash is stored, and regression tests compare the current output hash against it. If the hash changes without an explicit migration, the test fails.

6.4 Key Test Commands

# Determinism suite (core guarantee)
PYTHONPATH=. pytest tests/determinism/ -v

# CSC invariants
pytest tests/e2e/test_csc_unit.py -v

# GCI claim verification
pytest tests_agent/test_gci_v1.py -v

# ORC-v2 (TypeScript)
cd src/aria && npx vitest run

# Full gold gate (merge gate)
npm run test:gold

---

7. What ARIA Is Not

ARIA is not an LLM. It does not generate text, summarize documents, answer questions, or produce natural language. When LLM rendering is enabled, the LLM runs after the governance gate as a constrained renderer.

ARIA is not a chatbot. The chat interface (GCI-v1) is a demonstration surface. The core system is a governance engine that produces gate decisions and evidence bundles.

ARIA is not an autonomous agent. It does not set its own goals, plan multi-step strategies, or take actions independently. It evaluates proposed actions and either allows, dampens, or blocks them.

ARIA is not a probabilistic classifier. Gate decisions are deterministic threshold comparisons. Given the same input state and the same input event, the system produces the same gate decision every time.

The CFM substrate does not model identity or entities. The 11 state variables are abstract numeric quantities (coherence, energy, stability, phase, alignment). They do not represent beliefs, preferences, personality, or any cognitive entity. The verify_identity_safety() method on CFMCoreV2 returns True unconditionally by design.

---

8. Scope and Roadmap

v0.3: Stabilization

This version represents the stabilization milestone:

• The deterministic governance pipeline (19-stage SystemTickCoordinator) is implemented and tested.
• The CFM core v2 substrate (5 channels, 11 variables, phi-derived parameters) is implemented and tested.
• The evidence bundle system (write, load, verify) is implemented and tested.
• 233 determinism tests pass across 8 phases.
• 5,000+ total tests pass across all subsystems.
• The gate decision logic (ALLOW / DAMPEN / BLOCK) is a pure function of measured state.

What This Document Describes

This document describes what exists in the codebase and is covered by passing tests. It does not describe planned features, theoretical capabilities, or aspirational goals. Every claim in this document can be verified by running the corresponding test suite or inspecting the referenced source files.

Key Source Files

---

ARIA Technical Brief v0.3 -- February 2026