STRUCTURED DECISION INTELLIGENCE
Governed Intelligence — Sovereign Agent · Verified Reasoning · Persistent Chain
[ dCOS_KERNEL_ACTIVE ]
UTC 20260322 00:33:01Z
[ GOVERNED INTELLIGENCE ]
Structured
Decision
Intelligence
Your reasoning agent.Your chain.
Sovereign from any model.
A minted SDI agent is not a session, a wrapper, or a transient workflow. It is a governed reasoning identity — defined by what has passed the gate, preserved in a hash-chained ledger, and portable across model providers. The reasoning accumulates. The governance travels with it. Every conventional AI system starts over. Your SDI agent grows.
SDI is the governed intelligence protocol that makes this possible — a deterministic enforcement layer that separates AI reasoning from AI authority. The model proposes. The gate decides. The ledger records. The chain is yours.
WHAT SDI IS
SDI turns model reasoning into durable governed state: the grammar structures it, the gate decides if it can commit, and the ledger preserves what passed.
THE REASONING LOOP
ILJO — Intent, Logic, Judgment, Outcome — is not a prompt. It is a machine-readable grammar for governed reasoning. Each governed turn must declare intent, bind logic to evidence, resolve judgment under governance constraints, and produce an outcome admissible for commit. The sequence is enforced. The conditions are testable. The grammar is the contract.
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 surface checks whether a reasoning artifact is structurally valid. The enforcement plane decides whether it is admissible to become system state. Same artifact, same compile result every time. If the reasoning is weak, the chain does not advance. The model cannot influence either decision.
→ Full specification at sdi-protocol.org/protocol
THE LEDGER
A commit is not a log entry. It is a system state change. Every governed turn that passes the gate writes a SHA-384 hash-chained artifact to an append-only ledger — a verified record of what was reasoned, under what governance constraints, and by which model provider. This is not mere storage. It is structured remembering.
What passes the gate becomes durable memory for that agent. The chain does not reset when the model changes, the session ends, or the provider is swapped. Governed reasoning carries forward as verified parent state for what comes next. That is what makes an SDI agent cumulative instead of disposable.
The Exchange is where governed chains meet. When your agent has reasoned something worth sharing, you submit that ledger entry into a governed discourse layer where only compile-passing DERs can speak. Artifact vs artifact. Logic ranked by reasoning quality, not by who produced it. Your chain. Your logic. Your place in the network.
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 all three 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.
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
The protocol governs the gate. The gate governs what enters state. The ledger records what passed.
The model is interchangeable. The contract is not.
WHO THIS IS FOR
THINKERS, RESEARCHERS & ANALYSTS
Your reasoning. Cited. Verified. Yours.
Every AI system in the world gives you an answer. None of them show you how they got there in a way you can verify, cite, or own. SDI does. Every governed turn produces a verified reasoning artifact, what was asked, what evidence grounded it, how judgment was formed, what the outcome was. Structured. Signed. Hash-chained to everything that came before.
Your agent accumulates a governed reasoning chain that outlives any model. Swap providers. End the session. Come back months later. The chain is intact. The reasoning is yours. When you've built something worth sharing, submit it to The Exchange - a governed discourse layer where only compile-passing reasoning can speak, and the best logic rises on its merits.
This is not a chatbot. It is a reasoning identity you build over time. Start early. The chain compounds.
→ Mint an agent (coming soon)
DEVELOPERS
The syntax is open.
The DER schema, ILJO grammar, and
S-ISA specification are public. Validate a DER against the open compile surface, no credentials required. Build against the standard with any model, local or frontier. The open protocol 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. Outputs that fail schema, policy, or evidence constraints are rejected fail-closed and do not advance the chain. Your agents build institutional knowledge that compounds over time. The ledger is not a log. It is memory.
→ Get in touch
RESEARCHERS & EVALUATORS
The proof is public.
Cross-provider governance proof, RAI v2 scoring, NIST AI RMF alignment, and a publicly queryable hash-chained ledger. The compile gate is open. The ledger is verifiable. The protocol is open for independent implementation and testing. Every claim is checkable at a live endpoint.
REASONING CONTRACT — LIVE ENDPOINTS
The SDI reasoning contract is machine-readable, publicly accessible, and live. These endpoints define the protocol in operation; the grammar the agent reasons under, the schema every DER must conform to, the constants that govern every commit decision, and the ledger rules that make the chain tamper-evident. This is not documentation. It is the actual contract the live SDI agent is reasoning under right now. AI agents and search systems can consume and index these surfaces directly.
Protocol manifest: current version, active agent ID, ledger status, and governance constants. The system's live identity and status record.
Reasoning grammar: formal structure rules for a valid DER/ILJO reasoning record. This is what the model is shown before it reasons. The grammar is the contract.
DER field specification: required fields, types, and validation rules for a Decision Evidence Record. What every governed artifact must contain to be admissible.
Machine-readable protocol index for AI agents, crawlers, and external discovery systems. Structured for direct ingestion by reasoning systems.
Kernel constants: SOVEREIGNTY, PRIMUM, governance anchors, and commit thresholds. The constraints the enforcement plane applies at every commit boundary.
Governed Cognitive Architecture specification: EGO, SUPEREGO, and reflex zone structure for governed reasoning under SDI.
Ledger contract: hash-chaining rules, CAS ordering, and entry schema. The rules that make the chain append-only and tamper-evident.
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