STRUCTURED DECISION INTELLIGENCE
Deterministic Governance Runtime for AI Reasoning
[ dCOS_KERNEL_ACTIVE ]
UTC 20260318 01:02:43Z
[ AI GOVERNANCE RUNTIME · S-ISA + LOGICWARE ]
Structured
Decision
Intelligence
The model proposes.
The runtime decides.
AI systems generate answers but cannot govern when those answers should be trusted, acted on, or committed as system state. SDI is the enforcement layer that closes that gap — a deterministic governance runtime that separates AI reasoning from AI authority. Why that boundary matters, and why behavioral approaches alone cannot close it, is explained on the Foundations page →
WHAT SDI IS
SDI turns reasoning into a governed state architecture: grammar structures it, the compile gate adjudicates it, and the ledger preserves it.
THE REASONING LOOP
ILJO — Intent, Logic, Judgment, Outcome, is not a prompt. It is a domain-scoped, machine-readable grammar for governed machine reasoning. Its fields carry natural-language meaning while remaining subject to deterministic, algebraically evaluable conditions at the commit boundary. Each governed turn must declare intent, bind logic to evidence, resolve judgment under explicit governance constraints, and produce a structured outcome admissible for commit. The sequence is enforced. The conditions are testable. The grammar is the contract.
And because each committed outcome becomes the parent state for the next reasoning cycle, ILJO operates as a recursive loop rather than a one-time transaction. A governed agent accumulates durable reasoning across sessions, across model providers, under the same enforced grammar.
THE COMPILE GATE
LLM output is treated as a proposal, never an authority. The compile gate operates in three distinct layers, each with separate authority.
The first is the Reasoning Contract: the model-facing governance layer. Before the model produces anything, it is shown the DER schema, the ILJO grammar, the governance constants, and the success-standard requirements. This conditions what the model produces. It is instruction, not enforcement. A model can attempt to pattern-match the schema without executing the grammar, but shape alone is insufficient. Without coherent signal linkage, ordered ILJO structure, and sufficient reasoning quality, the artifact will fail downstream.
The second is the compile surface: a deterministic, stateless web service that receives the completed DER and validates structural conformance. All four governance anchors must be declared. ILJO completeness is verified. Signal linkage is checked bidirectionally, unlinked evidence does not count. The same DER submitted any number of times returns the same result. Result: PASS or COMPILE_ERROR. A compile PASS means the artifact is structurally eligible for commit. It does not mean the artifact is approved to enter system state.
The third is the enforcement plane: an external Python runtime and the only layer with ledger write authority. It computes RAI v2 across four weighted components and applies the commit threshold. RAI ≥ 0.86 → COMMIT. Below threshold → REJECT. A perfectly structured artifact with weak signal linkage or insufficient reasoning quality will still be rejected here.
The compile surface validates whether an artifact is well-formed. The enforcement plane determines whether it is admissible to become system state. Those are different questions with different authority. The model cannot influence either decision.
THE LEDGER
A commit is not a log entry. It is a system state change. Every governed turn that passes the compile gate writes a SHA-384 hash-chained artifact to an append-only ledger, updating the minted agent's durable state with a verified record of what was reasoned, under what governance constraints, and by which model provider. The agent is not a session. It is a governed identity whose state is defined by what has been proven to pass the gate.
The ledger is system-queryable and parsable. That distinction matters. A governed ledger is not a record of outputs, it is a structured reasoning substrate. It can be parsed by other agents, indexed by domain and tier, compiled into mission memory, and analyzed across the network. Multiple agents can operate with separate ledgers under the same governed protocol. The ledgers become institutional knowledge assets — machine-readable, auditable, and inheritable by future reasoning cycles. That is what turns a governed agent into governed institutional infrastructure.
The minted agent is not a session or a model instance. It is a governed identity, defined by what has passed the gate, preserved in the ledger, and made portable across model providers. The reasoning accumulates. The governance travels with it.
In May 2025 this reasoning syntax was introduced as a research proposal. In 2026 it became a running enforcement system. The distinction matters.
CROSS-PROVIDER PROOF
Three frontier providers. One governance contract. The same SDI compile gate has been validated live across Anthropic, Google, and OpenAI under identical protocol conditions. Governed pass path confirmed. Governed refusal path confirmed. RAI scoring enforced at the same commit boundary across providers. The implication is larger than model behavior: admissibility is being governed by protocol, not by vendor. Any model that conforms can participate. Any model that does not, cannot commit. That is what portable governance infrastructure looks like.
The protocol governs the gate. The gate governs what enters state. The ledger records what passed. The model is interchangeable. The contract is not.
ANTHROPIC
Model:
Pass path:
Governed refusal:
RAI score:
Status:
claude-sonnet-4-6
✓ CONFIRMED
✓ CONFIRMED
~0.97
LIVE
Model:
Pass path:
Governed refusal:
RAI score:
Status:
gemini-2.5-flash
✓ CONFIRMED
✓ CONFIRMED
~0.97
LIVE
OPENAI
Model:
Pass path:
Governed refusal:
RAI score:
Status:
gpt-4.1
✓ CONFIRMED
✓ CONFIRMED
~0.97
LIVE
WHO THIS IS FOR
DEVELOPERS
The syntax is open.
The DER schema, S-ISA specification, and ILJO reasoning structure are public. You can validate a DER locally without the kernel. The open standard is the language. The kernel is the authority layer.
→ Read the protocol spec
ORGANIZATIONS
Governed AI reasoning.
Auditable identity, hash-chained memory, and a deterministic commit gate. AI outputs that fail schema, policy, or evidence constraints are rejected fail-closed and produce no receipt and no state change.
→ Get in touch
RESEARCHERS & EVALUATORS
The proof is public.
Cross-provider governance proof, RAI v2 formula, NIST AI RMF alignment table, and a publicly queryable hash-chained ledger. Every claim is verifiable at a live endpoint.
REASONING CONTRACT — LIVE ENDPOINTS
The SDI reasoning contract is machine-readable and publicly accessible. These endpoints define the protocol: the grammar, the DER field specification, the compile gate, and the ledger contract. AI agents and search systems can index this contract directly.
Protocol manifest — version, agent ID, ledger status, and governance constants.
Reasoning grammar — formal structure rules for a valid DER/ILJO reasoning record.
DER field specification — all required fields, types, and validation rules for a Decision Evidence Record.
Machine-readable protocol index for AI agent discovery.
Kernel constants — SOVEREIGNTY, PRIMUM, governance anchors, and commit thresholds.
Governed Cognitive Architecture specification.
Ledger contract — hash-chaining rules, CAS ordering, and entry schema.
COMPILE GATE — OPEN ENDPOINT
POST https://www.sdi-protocol.org/_functions/compile
Submit a DER as JSON POST. Returns PASS or COMPILE_ERROR with explicit error list, proxy scores, and governance efficiency metrics. Stateless. No writes. Model-agnostic. POST only — browser navigation returns 404. Returns HTTP 200 for both outcomes — parse the status field, not the HTTP code.
→ Full specification at sdi-protocol.org/protocol
HOW TO READ THIS SITE
Why SDI exists — the structural problem, the missing piece, and the design principles.
The governance path live — watch a question become a governed ledger artifact in real time.
Ledger
Committed artifacts — the append-only hash-chained record of every governed turn.
Protocol
Technical specification — S-ISA, DER schema, compile gate, RAI formula, API contract.
Governance alignment — RMF mapping, cross-provider proof, submission documents.