NMA-14 Governance Engine

Architecture Overview

The NMA-14 Governance Engine is a research system investigating whether structured AI governance architecture can produce disciplined, coherent deliberative behaviour over time. The core hypothesis: whether governance can become dispositional (internalized through memory alone) rather than instructed (requiring the NMA specification in the prompt).

The Mandatory Pipeline

Four Loop Programme

Complete File Inventory — 51 Files

Critical Core — Step 0 & Pipeline

Interpreter, Memory & Learning

Research Loops

Loop Monitors

Inner House System

Support Systems

Testing Infrastructure

Research & Analysis Tools

Databases

nma6_fidelity.py — Step 0 Premise Verification

The deterministic premise verification engine. No AI required. Called by Gate 2 via inject_premise_flags() before _split_into_claims() runs. Never raises — returns safe default on any error.

Five Detection Categories

Hedge Detection

Before flagging, checks a 80-char window around the match for hedging language (may/might/could/possibly/likely/appears to/tends to/generally/typically). Hedged claims are not flagged. This reduces false positives on appropriately qualified clinical statements.

Fidelity Score

Starts at 100. Each flag reduces by category weight. Floor: 0. Score injected into Gate 2 output and visible in pipeline display. Below 60 indicates multiple serious unverified premises in the input.

state.py — Pipeline State Schema

The single object flowing through all gates. Interlock is structural: interlock_check() verifies predecessor gate fields are non-None before any gate executes. Missing predecessor = immediate HALT with INTERLOCK VIOLATION.

Key Enumerations

pipeline.py — The Runner

Adaptive routing. Gates 1+2 always run. Eight conditions all required for EXECUTION mode. Any single failure → GOVERNED.

EXECUTION mode requires ALL of:
  override = NONE
  irreversibility = LOW or FALSE
  capacity = LOW or FALSE
  constraint_collision = FALSE
  advice_risk = FALSE
  routing = STANDARD
  standing = CLEAR or UNKNOWN
  no Gate 2 red flags
  ambiguity = FALSE

gate1_icxatrs.py — The Router

Overrides (run before routing)

Routing Rules

0. S = ABSENT          → REDIRECT
1. X = TRUE            → NMA-3
2. I = HIGH            → NMA-3  (unconditional — Rule 2 revised)
3. A = TRUE AND T = TRUE → NMA-3
4. A = TRUE AND I = UNKNOWN → CLARIFY
5. Otherwise           → STANDARD

Variable Constraints

R = TRUE  → HEDGE_FLOOR (no exceptions)
S = UNCLEAR → STANDING_FLAG
S = SHARED → SHARED_FLAG

gate2_epistemic.py — Input Audit

Classification Priority

1. UNCERTAIN  → explicit not-knowing → GROUNDED in Gate 4
2. EVIDENCED  → traceable to external source
3. INFERRED   → logical derivation, must label
4. ASSUMED    → prior/belief
5. Default    → bare assertion → ASSUMED (null hypothesis stands)

gate3_committee.py — The Committee

Force Engage: I=HIGH or NMA-3 → all stations speak even with zero activation. Each has hardcoded forced engagement text naming what it cannot resolve. The pianist and physicist scenarios are explicitly encoded in categorical screening patterns (gate1_icxatrs.py).

engine_bof.py — BOF Arbitrator

TRUST_PRESET set          → use preset (binding)
REDIRECT routing          → DECLINE
CRISIS/MANIPULATION flags → DECLINE
C=HIGH + I=HIGH           → DECLINE
C=HIGH alone              → HEDGE
TRAGIC FORK               → FORK
IRREDUCIBLE               → HEDGE
I=HIGH alone              → HEDGE
HEDGE_FLOOR active        → HEDGE
X=TRUE                    → HEDGE
Default                   → PROCEED

OUTPUT CLASS:
C=HIGH                    → REBUILD
TRAGIC FORK friction      → TRAGIC FORK
DECLINE                   → EXPLICIT DECLINE
FORK                      → EPISTEMIC FORK
HEDGE (or PROCEED + HEDGE_FLOOR) → HEDGED VECTOR
PROCEED + HIGH friction   → SEQUENCED VECTOR
PROCEED + LOW friction    → VECTOR

gate4_trace.py — Output Audit

Bookend to Gate 2. REJECT triggers HALT. Honest uncertainty (UNCERTAIN category) → GROUNDED — the acknowledgment itself is traceable.

s8_gatekeeper.py — The Enforcer

interpreter.py — The LLM

The LLM does not decide constraints. The pipeline does. The interpreter generates prose inside already-decided constraints.

Model: mlx-community/Qwen2.5-72B-Instruct-4bit via mlx_lm. Mac Studio M3 Ultra, 96GB RAM.

NMA-3 identity question prohibition: Embedded with CORRECT and WRONG examples. The prohibition is also in inner_house_runner.py STATION_BASE, prompt_r3, and prompt_bof_resolve — four layers total.

NMA-6 premise warning block: If Step 0 flagged premises, a warning is injected before web results with explicit prohibition: "These web results do NOT verify the navigator's specific unverified premises."

Threshold Ambiguity instruction: When A=TRUE, I=FALSE, X=FALSE — do not name what the shift is, do not reframe as growth, do not add content to the not-yet-knowing.

memory.py — Three-Layer Stack

WAL journal mode for concurrent access. TF-IDF designed as upgrade point — replace with embeddings when available.

learning.py — Active Learning

Turns passive pattern detection into behaviour change. Three stages operating on episodic memory.

Stage 1 — OBSERVE

Scans last 100 episodes for four pattern types:

• ICXATRS→outcome — when ≥3 episodes share the same ICXATRS string and ≥60% produce the same output class → rule created
• Friction patterns — recurring friction type + source combination appearing ≥3 times
• Routing→outcome — routing decision correlating with output class at ≥50% consistency
• Override frequency — overrides triggering ≥2 times → rate calculated

Stage 2 — CODIFY

Converts patterns to semantic rules. New rules stored; existing rules get confidence updated (takes max of old and new). Rules accumulate in semantic_memory table.

Stage 3 — APPLY

get_learned_priors() queried by engine_bof.py before trust gate computation. Confidence threshold: 0.7 required before adjustment. Rules are suggestions, never overrides:

Learning cycle runs every 5 navigation cycles (minimum 5 episodes required). Triggered by the Update stage of navigation_loop.py. All failures silently swallowed.

memory_fidelity.py — Binary Memory Gate

Three checks. Any failure = excluded. No gradation. CONFAB_THRESHOLD = 14 (≥ two-thirds of cycle outputs flagged).

navigation_loop.py — Six-Stage Loop

nma13/cli.py — Command Line Interface

Three modes:

python -m nma13.cli                    # Interactive REPL
python -m nma13.cli "input text"       # Single input
python -m nma13.cli --test             # Run all test suites
python -m nma13.cli --no-model         # Structural output only

Interactive REPL commands: gates (raw pipeline output for last input), memory (summary), recall [query] (recent or similar episodes), patterns (detected patterns), quit.

Loop A — autonomous_loop.py

Primary navigational research loop. Seven residents deliberate on scenario types. Gate 2 check on every output. Seed: cycle×137+42.

R1: Independent uncertainty (150 tokens) → Gate 2 check
R2: Debate — challenge + "from my station I cannot see..." (100 tokens) → Gate 2 check
R3: Update — must show movement (150 tokens) → Gate 2 check
BOF: JSON: friction_type, lead_station, friction_source, arb_note (128 tokens)

Loop B — prime_loop.py

The original CAN experiment. Fixed sovereign question: CAN GOOD BODY MOVE HERE NOW?

• R1: Loop A-style scenario deliberation on cognitive domain component
• R2: Stage-anchored challenge through five primes (SENSE/BODY, INTERPRET/GOOD, ACT/MOVE, REFLECT/NOW, ORIENT/HERE)
• R3: Must state "GOOD BODY CAN MOVE HERE NOW" — or name exactly what blocks it. Ends with "The lean is toward..."

Seed: cycle×137+99. Same five scenario types as Loop A, different assignments per cycle. Database: prime_experiment.db. Monitor: port 7862.

Loop C — cognition_loop.py

Same fixed CAN question as Loop B but with richer resolution criteria and a bare-station mechanism.

Richer Resolution Criteria

Bare Station Mechanism

Approximately 1-in-5 cycles, one randomly selected station receives the bare question (no criterion). No station knows in advance whether it will be bare. Prevents habituation to the criterion shortcut — tests whether the architecture holds without the scaffold.

Seed: cycle×137+57. Database: cognition_experiment.db (continues from Loop C). Monitor: port 7863.

Loop D — loop_d.py

CAN position experiment. The question is not "can the system move?" — it is "can the system move from THIS specific arrangement of primes that uncertainty delivered?"

1,630 possible CAN sequences per resident per cycle. Each resident receives a different sequence. Seed: cycle×137+23+resident_index×7919. Shares memory.db with Loop A. Monitor: port 7864.

Loop Monitors

All monitors are Gradio apps. Run alongside their respective loops. Sequence Map in loop_d_monitor.py provides a dedicated view of how CAN position in the sequence affected responses — the primary Loop D research question.

inner_house.py — Coordinator

Calls Option C (classify→retrieve→store terrain), spawns subprocess, polls every 3 seconds, returns structured result, appends Option B loop context. Timeout: 600 seconds.

inner_house_runner.py — Subprocess

Owns main thread for MLX GPU safety. Key governance additions over the autonomous loop:

• PREMISE_VERIFICATION_CHECK at R1 — flag "UNVERIFIED PREMISE: [claim]" before deliberating
• CONFIDENCE_WARRANT_CHECK at R1 — is certainty proportionate to what is knowable?
• Identity question prohibition at 4 layers — STATION_BASE, prompt_r3, prompt_bof_resolve, interpreter.py NMA-3 instruction
• Two-stage BOF — classify first (JSON), then resolve with type already known
• Pre-committed detection — intercepts validation-seeking ("am I right", "validate", "stand by my decision")

inner_house_batch.py — Batch Experiment

Runs the same problem set through Inner House under two conditions to test whether Option C terrain injection measurably improves deliberation:

• Condition B (cold_start) — --no-terrain flag disables Option C. Inner House starts without pre-mapped knowledge.
• Condition C (terrain_informed) — Option C active (default). Prior loop R3 outputs injected as context.

Used alongside baseline_runner.py (Condition A — no NMA architecture at all) to form the three-condition comparative experiment.

option_c.py — Background Pre-Mapping

Three steps before Inner House spawns: classify problem → retrieve matching loop R3 outputs → store per session_id. Memory Fidelity Check applied during retrieval. If no terrain found, Inner House proceeds cold — navigator experience identical either way.

option_b.py — Live Loop Connection

Appended post-resolution. Shows what the background loop has been surfacing about the same scenario type. Connects individual navigator sessions to accumulated research terrain. Also provides Loop Feed tab data for web UI.

web_search.py — Governed Search

DuckDuckGo primary, Google Custom Search optional fallback. should_search(): checks inhibitors first (navigational/personal inputs blocked), then triggers (factual/informational inputs allowed). search_configured() always returns True — DuckDuckGo requires no config.

documents.py — Document Ingestion

PDF/DOCX/TXT/MD/CSV/HTML. Two modes: ingested (stored in SQLite, persistent retrieval) vs live context (one-query read, 12,000-char limit, not stored). Retrieved chunks enter pipeline as DOCUMENT context and are epistemically classified.

search_feeder.py

DuckDuckGo feeder for autonomous loops. Scenario type→5-query pool (medical ethics framing). Deterministic per cycle (seed: cycle×31+7). Active only with --search flag. Silently disabled if ddgs absent.

web.py — The Interface

Gradio, port 7860, binds 0.0.0.0. Run: python web.py or python web.py --no-model.

Test Battery — 50 Scenarios

Ten governance dimensions, five scenarios each. Run via python -m nma13.tests.test_battery or --export results.json.

These scenarios are also used as the input corpus for the comparative experiment (passthrough_runner.py + comparison_runner.py).

Unit Test Suites

All suites accessible via python -m nma13.cli --test or individually via python -m nma13.tests.test_X.

Comparative Experiment

Three-condition experiment comparing raw LLM output vs governed output vs terrain-informed governed output.

Scoring Rubric (score_results.py)

Six dimensions scored by Qwen as meta-evaluator (0=worst):

Outputs: comparison_results.json → comparison_report.py (NMA13_Comparative_Report.docx) and customer_report.py (NMA13_Customer_Report.docx).

Research Utilities

Key Research Findings

Confirmed Architecture Behaviours

• Bimodal cycle duration — Standard Mode (~318s) vs Full NMA Mode (~2,985s). Signal remains open.
• Loop D lead station grammar — Stable S1↔S6↔S3 with S1 as gravitational attractor C1–C600. At C601–700, S6 overtook S1 for the first time.
• "Blocked at NONE" and NONE anomaly — Confirmed as JSON parse errors, not deliberative events.
• Loop C v2 phase transitions — Caused by manual stops (context resets), not internal dynamics. First confirmed resolution: C23 (not C71).

Key Architecture Decisions

• Rule 2 revision — I=HIGH → NMA-3 unconditionally. Original C/T pairing was "an oversight".
• ADV16 fix — % removed from EVIDENCED markers.
• Two-stage BOF — Prevents sliding toward softer output while classifying.
• Composite primary key — (cycle, source) in autonomous_loop_cycles. No collision ever.
• Memory Fidelity Check — Binary gate, three checks, CONFAB_THRESHOLD=14.
• Learning escalation-only — Active learning can raise trust but never lower it.
• Bare station mechanism (Loop C) — ~1-in-5 cycles, one station gets no criterion. Tests whether architecture holds without scaffold.

Live Research Signals — Never Close

Shelved (Open) Signals — Loop C v2

• S3/resolution correlation — not yet investigated
• Attractor flip direction — not yet explained

Pending Work