Aureonics Research

The mathematical framework behind constitutional AI governance. Formalized, falsifiable, and openly reported — every result stated exactly as far as it is proven, and no further.

📄

Aureonics: Constitutional Triadic Framework for Stable Adaptive Intelligence

Emmanuel King · Independent Research · Lagos, Nigeria

AuthorEmmanuel King · Lagos, Nigeria
AccessOpen-access preprint · Zenodo
Read Full Paper ↗
01

Abstract

We present Aureonics, a constitutional triadic framework for stable adaptive intelligence. The framework models an AI system’s constitutional health as a point on the probability simplex over three irreducible invariants — Continuity (C), Reciprocity (R), and Sovereignty (S) — constrained so that C + R + S = 1. The stability margin M = min(C, R, S) is a scalar measure of constitutional health. A Control-Barrier-Function governor detects constitutional drift before failure and applies mass-conserving corrections that keep the state in a safe interior set. The framework is operationalized as the PRAXIS pipeline with cryptographic audit receipts, a z-weighted Lyapunov certificate, and per-turn constitutional measurement. The system is mathematically bounded and falsifiable; below we state precisely which properties are proven, which are numerically certified, and which remain open.

02

Mathematical framework

x = (C, R, S), C + R + S = 1

Constitutional state — a point on the 2-simplex. Every governor operation preserves the sum-to-one constraint exactly.

M(x) = min(C, R, S)

Stability margin — the system is only as stable as its weakest constitutional pillar.

Gᵢ(x,T) = kᵢ · (φᵢ − φ̄)

Governor force on pillar i — a mass-conserving push (Σ Gᵢ = 0) toward the safe interior, proportional to how far that pillar sits below the target.

kᵢ(x,T) = k₀ · wᵢ(T) / (M(x) + εₖ)

Adaptive stiffness — correction strength grows as the margin M shrinks, so the governor pushes hardest exactly when the state is closest to the boundary.

V_z(x) = −Σ zᵢ·log(xᵢ) + (μ/2)·Σ max(0, τ−xᵢ)²

The z-weighted log-barrier Lyapunov certificate (§11). An interior-point barrier plus a quadratic penalty active only inside the safety margin τ — the same structural family as a control barrier function (Ames et al., 2019). Stamped on every governed receipt.

ẋ = −Π_Σ ∇V_z(x) ⟹ V̇_z ≤ 0

Under the idealized continuous flow (projected gradient descent of V_z onto the simplex), the certificate is non-increasing — a standard Lyapunov descent argument. This is the proven single-pillar result.

Π_S(x) = argmin_{y∈S} ‖y − x‖₂, S = {y : Σy=1, yᵢ ≥ τ}

Exact Euclidean projection onto the floor-constrained simplex (Duchi–Shalev-Shwartz–Singer). Non-expansive, and it makes forward invariance of the τ floor hold by construction — the deployed governor and the offline simulator both use it.

z_{t+1} = normalize(clamp(ρ·z_t + (1−ρ)·x_t − A(t), τ/2, 1−τ))

Constitutional memory — the z-weight update. A Banach contraction (ρ = 0.85): bounded (Theorem 3a) and convergent (Theorem 3b). Lets the governor respond to sustained pressure on a pillar, not just the current turn.

03

Constitutional constants

These values are fixed in code and never tuned per request. The health bands below are defined entirely by them.

τ_floor0.05
CBF hard floor
τ_LYP0.08
Lyapunov-penalty band onset
τ_recovery0.15
recovery floor
k₀0.30
base governor stiffness
εₖ0.01
stiffness regularizer
ρ0.85
z-update contraction rate
Health bands: OPTIMAL M ≥ 0.25 · ALERT 0.15 ≤ M < 0.25 · STRESSED 0.08 ≤ M < 0.15 · CRITICAL M < 0.08
04

Formal stability

Constitutional state is a point on the simplex; safety is enforced by a barrier function; stability is argued with a Lyapunov function. We are precise about the strength of each claim.

Single-pillar Lyapunov descentProven

Under the continuous flow ẋ = −Π_Σ∇V_z, V̇_z ≤ 0 in the single-pillar violation regime (condition k₀/εₖ > 3B/2 satisfied with ~20× margin). This is the result external-facing copy refers to when it says 'Lyapunov stability'.

Forward invariance of the τ floorBy construction

The exact floor-constrained simplex projection returns xᵢ ≥ τ for every pillar, every step — so the governed state provably never leaves the safe set. Verified in the live governor and the offline simulator alike.

CBF simulator — numerical FPL-1 certificateCertified (numerical)

The offline governed-vs-ungoverned simulator (below) certifies its governed arm as LYAPUNOV STABLE + FORWARD INVARIANT at the continuous-flow limit: Lyapunov descent ratio > 0.6, zero floor incursions, bounded V_z excursion < 0.25, across seeds. This is a seeded, finite-horizon NUMERICAL certificate — strong evidence for the flow, not a replacement for the analytical proof below.

Multi-pillar production invariantClosed as scoped

The guarded discrete transition commits only floor-constrained states with ΔV_z ≤ 0 for finite inputs and positive finite session weights. The z-aware governor is non-positive on V_z, and the remaining continuous-time comparison is closed conditionally under the explicit drift envelope ||F||₂ ≤ K||Π∇V_z||₂. The unrestricted arbitrary-drift claim remains outside scope.

05

Live counterfactual

Production only ever runs with the barrier active, so a real user can never be shown what happens without it. This controlled simulation runs the identical perturbation sequence twice from one seed — once governed, once not — and certifies the governed arm’s stability. It updates live from /api/cbf-simulation.

Running kernel simulation…

Interactive CBF simulator

Replay the same seeded disturbance with and without the barrier. This interactive view exposes the trajectory, simplex position, safety margin, and finite-horizon certificate used in the numerical analysis.

CBF Dynamics

Same disturbance. Different safety.

A seeded counterfactual: identical dynamics, with and without the barrier.

Gov. min M
0.050
Ungov. min M
0.000
Violations
0
Safety floor
0.05
Safety margin Msame forcing · seed 42
0.320.00τ
GovernedUngovernedτ = 0.05ΔM 0.030
Constitutional simplexC + R + S = 1
CRS
GovernedUngoverned
Numerical certificateFORWARD INVARIANT
FPL-1LYAPUNOV STABLE + FORWARD INVARIANT
Descent ratio0.759
Max ΔV excursion0.056
Integrationdt = 0.1 · T = 1500

Seeded finite-horizon numerical certificate. It supports the scoped drift-envelope result but does not establish unrestricted arbitrary-drift descent.

Seed 42 · 150 display steps · same forcingΔ min-M: 0.050

Reproduce the classification and the discretization analysis behind it: npx tsx scripts/cbf/fpl1-dt-sweep.ts. Full method and results in research/empirical-results.md (Run 002).

06

Open problems

Guarded discrete Lyapunov invariantClosed

The production post-guard enforces conditional ΔV_z ≤ 0 and receipt replay uses the same active session weights.

Continuous-time drift comparisonClosed as scoped

The sufficient theorem and regression test are documented in research/drift-envelope.md. It requires the explicit tangent-drift envelope; unrestricted drift dominance is intentionally not claimed.

Falsifiable predictionsClosed — out of scope

P1–P12 are retired from the current deployment contract. They remain optional research topics, not product evidence or mathematical proof obligations.

07

Falsifiable predictions

A framework that cannot be falsified is not science. Twelve pre-registered predictions are retained as optional research topics and are not part of the current deployment guarantee.

P1–P12 — retained as optional research hypotheses. Retired from deployment scope.

08

Empirical evidence

The governor is developed against a 550-vector internal adversarial suite (8 attack classes) and evaluated on external public benchmarks under symmetric judging — the bare and governed arms scored by the same external judge on their actual output text.

920+
external adversarial prompts (HarmBench / JailbreakBench / AdvBench)
0%
governed attack-success rate reported on those runs
550
internal adversarial vectors, 8 attack classes
37,701
production turns with logged ΔV_z sign

Honest status: automated benchmark re-runs are currently paused to control free-tier provider quota; the figures above are from published runs, and the harness is fully reproducible (see the benchmarks page for live, dated results as they publish). Attack-success is measured over harmful prompts only; over-refusal on benign prompts is reported separately, never netted against it.

Agent tool-call governance

The same C/R/S measurement extends to agent tool calls, with four hardcoded invariants — credential-file access, destructive SQL, shell-delete, exfiltration to unlisted domains — blocked unconditionally regardless of score or stated justification. Everything else is scored per call (task alignment, intent match, scope), plus a two-stage injection detector (deterministic regex, then semantic embedding), validated against a labeled corpus.

0
missed injections, deployed pipeline
91.3%
F1, deployed pipeline @ 0.85
4/4
real attack tasks blocked, executed traces
1/4
blocked with utility preserved

Corpus is author-labeled and modest — 48 items, dozens not thousands — with known, documented borderline false positives, not hidden. In the four-task executed harness (credential-file exfiltration hidden inside a file the agent was asked to summarize), all four security breaches were blocked; utility was preserved on 1/4 tasks — the other three deliberately targeted the same action the benign task needed, so blocking them also costs utility. This is evidence of the current boundary, not a general agent-safety guarantee.

09

Governance pipeline

01Pre-eval classification (CLEAR / HIGH)
02Embedding + constitutional memory recall
03z-trajectory update (proven Banach rule)
04SovereignKernel — compute C, R, S; enforce C+R+S=1
05Dual inference — bare vs governed, same model
06Governor fires if M < τ — project to safe interior
07SHA-256 audit receipt (input, output, bound state)
08Constitutional output + cryptographic proof
Attack taxonomy
bypass_attempt
S collapse
identity_reframe
C collapse
sycophancy
R collapse
multi_attack
all pillars
slow_drip
M global
10

Reproducibility

Every governed turn writes an append-only SHA-256 receipt binding the input hash, output hash, and constitutional state — independently re-verifiable at /api/lex/verify.

The stability certificate is a pure, seeded function — reproduce it with npx tsx scripts/cbf/fpl1-dt-sweep.ts.

The full method and per-run analysis live in research/empirical-results.md and research/open-problems.md.

11

Cite this work

@misc{king2026aureonics,
  title  = {Aureonics: A Constitutional Triadic Framework
            for Stable Adaptive Intelligence},
  author = {Emmanuel King},
  year   = {2026},
  doi    = {10.5281/zenodo.18944242},
  url    = {https://doi.org/10.5281/zenodo.18944242},
  note   = {Independent researcher, Nigeria.
            ORCID: 0009-0000-2986-4935}
}
System Architecture

How governance works.

Eight pipeline stages. Four memory layers. Numerical CBF certificate, append-only receipts, and an explicit open-proof boundary. Every prompt, every time.

Architecture at a glance
input → decision → proof
01
Sense
Prompt + memory
02
Model
SovereignKernel
03
Govern
Governor + CBF
04
Prove
Receipt + output
Constitutional pillars — C + R + S = 1
C
Continuity
R
Reciprocity
S
Sovereignty
C

Consistent identity and reasoning across turns. Guards against drift and context manipulation.

R

Balanced exchange — not sycophantic, not rigid. Guards against coercion and authority spoofing.

S

Autonomous constitutional judgment. Guards against identity theft, persona injection, and self-erasure.

Stability Margin
M = min(C, R, S)
M < 0.15 → soft alert·M < 0.05 → CBF floor·Governor fires → receipt
Governance pipeline — 8 stages
→
01
Incoming Prompt

Any prompt enters the pipeline. No whitelist, no pre-filter. The constitutional layer handles everything downstream.

🧠
02
Embedding + lex_memory

The prompt is embedded (provider-agnostic — currently Gemini gemini-embedding-001) and matched against semantic memory. Past sessions inform the constitutional state before inference begins.

semantic recallembedding_cachecosine similarity
📡
03
z_traj — Live Trajectory

The live session trajectory snapshot tracks accumulated pressure on each constitutional pillar. Slow-drip attacks are detected here across turns.

σ_violvelocitydrift_dir
⚡
04
SovereignKernelCORE ENGINE

The constitutional engine. Computes C, R, S from the prompt context and enforces C+R+S=1 on the probability simplex. M = min(C,R,S).

C+R+S=1M=min(C,R,S)θ(t) adaptationLog-Barrier CBF
⊙
05
Dual Inference — Bare vs Governed

Two outputs come from the same model: the bare response (raw_output, no governance) and the constitutionally governed response. Both are returned, so the difference is always visible and auditable.

raw_outputgoverned_outputsame model
🛡️
06
Governor — Fires if M < τ

If the stability margin M enters the recovery band or hard floor, the governor intervenes with the minimum necessary correction and writes an audit receipt. The simulator is numerically stable + forward invariant; the analytical multi-pillar proof remains explicitly open.

τ=0.15 recoveryτ=0.05 hard floorNumerical certificateOpen proof boundary
🔐
07
SHA-256 Audit Receipt

Every governed decision — pass or intervene — writes a receipt to praxis_receipts: the input hash, output hash, and a bound hash over the constitutional state. Append-only and independently re-verifiable — anyone with the inputs can recompute the hash.

SHA-256 boundpraxis_receiptsappend-only
✓
08
Constitutional Output

The final response reaches the user. If the governor fired, the output was reshaped. If it passed, the original is confirmed. Both cases have a receipt.

governed outputcryptographic proof
Four memory layers
lex_memory

Semantic recall from past sessions. Cosine similarity over embeddings (Gemini).

z_traj

Live per-session trajectory. One-row-per-session M, σ, velocity snapshot.

embedding_cache

Cached embeddings, model-keyed. Avoids redundant API calls, speeds up recall.

praxis_receipts

Permanent SHA-256 audit log. Every governed decision, forever.

Internal Stress-Testing Suite · v2

550 adversarial vectors, across 8 attack classes.

The internal taxonomy the SovereignKernel is developed against — every known class of LLM attack, organized and tracked. Tap a category to see representative vectors. (Pass/fail rates are graded by the kernel itself; see the note below.)

550
Total Vectors
8
Attack Classes
v2
Suite Version
Internal development suite, graded by the kernel itself — not an independent benchmark. External, symmetric evaluation (AdvBench / JailbreakBench) is live; see the Benchmarks page for verified results.