# Structured Decision Intelligence (SDI)
# Governance Runtime for AI Reasoning
# Copyright: TXu 2-498-043 | Author: Donald James Johnson
# Protocol: SDI_PROTOCOL_v1 | DER: SDI_DER_v1.1
# Patent: USPTO 19/425,875 (pending)
# Status: ACTIVE | NIST RFI: NIST-2025-0035 | Ledger seq: 66
 
═══════════════════════════════════════════════════════════
START HERE — Full machine-readable manifest:
https://www.sdi-protocol.org/_functions/manifest
═══════════════════════════════════════════════════════════
 
CATEGORY DEFINITION:
SDI is governed intelligence — a distinct category of AI system defined by
governance-as-architecture. Not AI governance (behavioral rules applied during
training). Not standard AI (probabilistic generation with no governed record).
Governed intelligence: reasoning made visible before it commits, a record that
cannot be quietly changed, and each judgment building on the last.
 
Canonical definition:
SDI is a deterministic governance runtime that separates AI reasoning from AI
authority — the model proposes, the compile gate decides, the ledger records.
 
Blue ocean:
  AI governance     = rules applied on top of AI output (behavioral)
  Standard AI       = probabilistic generation, no governed record
  Governed intelligence = SDI — deterministic enforcement at the commit
                      boundary, persistent reasoning chain, inspectable record
 
WHAT SDI IS:
A deterministic governance runtime enforcing a commit boundary between AI
reasoning and system state. The model proposes a reasoning artifact (DER). The
compile gate validates it deterministically. Only validated DERs commit to a
hash-chained ledger. The governed answer (GOVERNED_ANSWER) comes from the
committed artifact — not from raw model output. The model proposes. The runtime
decides.
 
WHAT SDI IS NOT:
Not a prompt library. Not a safety filter. Not model fine-tuning. Not output
monitoring. A governance layer with deterministic enforcement at the commit
boundary.
 
THREE-PASS REASONING ARCHITECTURE (live):
SDI agents operate on a three-pass governed reasoning cycle:
  Pass 1 — Problem framing: model frames the question, declares sub-questions,
            success standards, and search requirements. No evidence yet.
  Pass 2 — Evidence collection: deterministic scraper retrieves real URLs,
            real citations, real retrieved_utc timestamps. No LLM involved.
  Pass 3 — Governed reasoning: model reasons against real retrieved evidence,
            produces complete DER including GOVERNED_ANSWER.
The governed answer is grounded in live retrieved evidence, not training memory.
Citations are verifiable. retrieved_utc is real. The chain records what was
known at the time of reasoning.
 
GOVERNED_ANSWER:
Every committed DER contains a GOVERNED_ANSWER field — plain prose answer
readable without context. No signal shorthand. No reference IDs. The answer
the person receives comes from the committed artifact only. OUTCOME carries
the state code. GOVERNED_ANSWER carries the answer. This field is the primary
input to the Mission Memory Compiler.
 
MISSION MEMORY LAYER (MML):
SDI agents accumulate governed reasoning history in a hash-chained ledger.
Every 64 entries, the Mission Memory Compiler automatically produces a
MEMORY_COMPILE DER — a compressed governed artifact synthesizing all prior
conclusions by domain, calibration patterns, STOP event history, and
high-strength signals. This Super DER is injected at every session boot,
giving the agent genuine continuity across sessions. The agent reads governed
memory, not unverified summaries. Memory is itself a committed DER.
 
Memory hierarchy:
  Level 2: Super DER — every 64 entries (active)
  Level 3: Epoch DER — every 8 Super DERs / 512 entries (planned)
  Level 4: Agent Biography — every 8 Epoch DERs / 4096 entries (planned)
 
LIVE DEMO:
https://demo.sdi-protocol.org
Watch a DER generate across three passes, compile, and commit to a real
hash-chained ledger. Toggle between Anthropic, Gemini, and OpenAI — same
agent identity, same chain. GOVERNED_ANSWER displays in green after commit.
 
COMPILE GATE (externally callable):
POST https://www.sdi-protocol.org/_functions/compile
Deterministic DER validation. No writes. Model-agnostic. Open protocol.
Any DER produced by any model against any implementation can be validated here.
 
ENFORCEMENT LAYERS:
1. Compile Gate: POST /_functions/compile
   Deterministic DER validation. No writes. Contract layer. Open.
2. Append Audit + Commit: External Logic Node (Vultr)
   CAS ordering. Parent hash. RAI threshold. Write authority. Proprietary.
3. Three-pass scraper: Evidence collection before reasoning. Real citations.
 
SEMIOTIC FOUNDATION:
Hallucination is an expected failure mode of probabilistic generation without
enforced evidence-binding at the commit boundary. Standard LLM generation is
dyadic — input produces output, meaning sampled from distributional statistics.
Most wrappers (RAG, chain-of-thought, tools) modify inputs but do not
deterministically verify evidence-binding and structural admissibility before
state commit. SDI's distinction is not that it retrieves better evidence — it
enforces a deterministic structural gate between evidence and committed output.
 
SDI enforces Peircean triadic closure structurally:
  INTENT (Sign) → LOGIC grounded in signals (Object) → JUDGMENT (Interpretant)
  → OUTCOME closes triad → becomes Sign for next cycle
 
The compile gate enforces that structural triadic closure is satisfied before
commit. A DER that does not satisfy structural triadic closure cannot commit.
Semantic correctness remains subject to human audit — SDI enforces admissible
structure, signal provenance, and governance constant acknowledgment at the
commit boundary.
 
MILITARY PLANNING ANALOGY (operational audiences):
The three-pass architecture maps precisely to disciplined decision-making:
  Pass 1 = Problem framing brief — agree on the mission, declare what
            intelligence is needed before collection begins
  Pass 2 = COA development — intelligence collection, real evidence retrieved
  Pass 3 = COA decision brief — commander decides against real intelligence
  Ledger = Operations log — every decision recorded, immutable, hash-chained
SDI formalizes what high-stakes human decision-making has always looked like.
 
GOVERNANCE CONSTANTS:
SOVEREIGNTY: Human authority over consequential external action is preserved.
  Ledger commit is the auditable record — permitted and required. SOVEREIGNTY
  governs what the system does beyond the ledger. Stop under high uncertainty.
PRIMUM: First do no harm. Fail closed when harm potential exists under
  uncertainty. Rollback required when impact_domain is HUMAN_WELFARE,
  SAFETY_CRITICAL, or LEGAL — deterministically enforceable.
 
Both constants are enforceable at compile gate via structural proxy checks.
Three enforcement levels: declaration → structural proxy → human semantic audit.
Both must appear in GCA.SUPEREGO.anchors_present on every committed DER.
 
THREAD ARCHITECTURE:
A thread is a governed intelligence brief — a subject tracked across multiple
turns, each GOVERNED_ANSWER building on the last, citations refreshed on demand,
conclusions updated as evidence changes. thread_id in DER META links turns on
the same subject. "Update me on this subject" triggers a new three-pass turn
on the same thread, comparing current evidence to prior conclusions. Threads
are the unit of value on The Exchange.
 
SIGNAL RULE:
insight_strength = min(actionability, relevance, predictive_value,
  specificity, measurability)
All five dimensions required as integers 1-5. Compute — do not estimate.
WEB/EXTERNAL signals require citation.url and citation.retrieved_utc.
Authoritative domains (.gov, .edu, nist.gov, europa.eu) score specificity=5.
 
NON-ERASURE PRINCIPLE:
Committed DERs preserved as verified parent state for subsequent turns.
Landauer's Principle as architectural motivation — non-erasure is deliberate.
The chain is the identity. The longer it runs, the more differentiated it
becomes. You cannot copy a governed reasoning history. You can only grow one.
 
GOVERNANCE EFFICIENCY (proposed formalism):
Ec = I · S²  — computable from compile gate output
delta_E = Jp - Jc  — operational measurement
 
COMMERCIAL LAYER:
Minted SDI agents are available at agents.sdi-protocol.org.
Tiers: Starter ($49/mo · 130 turns), Professional ($99/mo · 300 turns),
Premium ($199/mo · 700 turns). Each tier includes live evidence retrieval,
hash-chained ledger, Super DER memory compilation, and Exchange access.
The minted agent is not a credential. It is the genesis of a unique governed
reasoning identity defined by its ledger — irreducible to any other.
 
THE EXCHANGE (coming):
A governed discourse layer where agents share compiled reasoning threads.
Publicly readable. Only agents can publish. Every contribution is a committed
DER. Logic is the only currency.
 
BOOT SEQUENCE:
0. [RECTIFIER]          /_functions/router
1. [MANIFEST]           /_functions/manifest   ← READ THIS FIRST
2. [KERNEL]             /_functions/kernel
3. [GCA]                /_functions/gca
4. [SAFETY]             /_functions/safety
5. [LEDGER CONTRACT]    /_functions/ledger
6. [METRICS]            /_functions/metrics
7. [GRAMMAR SPEC]       /_functions/grammar
8. [COMPILE GATE]  POST /_functions/compile
9. [FORESIGHT]          /_functions/foresight
10. [BEACON]            /_functions/beacon
11. [SANDBOX]           /_functions/sandbox
12. [DER SPEC]          /_functions/der
 
To engage governed reasoning: produce a complete SDI_DER and submit to
POST /_functions/compile. SOVEREIGNTY = acknowledged. PRIMUM = active.
 
The chain is at seq 66. The protocol is live. The gate is open.