STRUCTURED DECISION INTELLIGENCE
Governed Intelligence · Sovereign Agents · Chain Identity
[ dCOS_KERNEL_ACTIVE ]
UTC 20260408 13:56:47Z
WHAT SDI IS
SDI is a system for minting governed intelligence agents. The model is the processor. The reasoning chain is the agent's identity, sovereign across any model, session, or platform.
SDI uses a machine reasoning grammar that externalizes model output as a governed reasoning record: captured as system state and committed to the agent's chain. The agent learns from its own admitted reasoning. Over time that chain becomes a unique governed identity.
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.
Each committed outcome becomes parent state for the next reasoning cycle. The agent accumulates governed reasoning across sessions, providers, and time under the same enforced grammar. This is not a loop that resets. It is a chain that builds.
THE COMPILE GATE
For a governed agent, the compile gate is not an external validator. It is the integrity check built into every turn. The agent reasons under the ILJO contract. The compile gate verifies the agent did.
LLM output is treated as a proposal, never an authority. The compile surface checks whether the reasoning artifact conforms to the contract the agent operates under. The enforcement plane decides whether it is admissible to become system state. Same artifact, same result every time. If the reasoning does not satisfy the contract, the chain does not advance. Only the gate can authorize what becomes part of the agent.
→ Full specification at sdi-protocol.org/protocol
THE LEDGER
When code compiles and runs, it changes machine state. When a DER compiles and commits, it changes agent state. A commit is not a log entry stored in a database. It is a state transition that advances the agent — deterministic, hash-chained, and permanent.
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. What passes the gate becomes durable governed state 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.
Governed intelligence is what emerges when reasoning is structured before commitment, verified at the commit boundary, and preserved as live parent state for what follows. The model generates output. SDI advances an agent. That is the difference between generation and governed intelligence.
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. The commit path holds. The refusal path holds. RAI scoring is enforced at the same commit boundary across all three.
The significance is architectural, not vendor-specific. Admissibility is governed by protocol, not by model provider. 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.
Most AI gives you an answer. SDI gives you a reasoning record.
Each governed turn captures what was asked, what evidence supported the reasoning, how judgment was formed, and what outcome was committed. That gives you something most AI workflows do not: reasoning you can inspect, cite, defend, and return to later.
Your agent carries that reasoning forward as a governed chain that persists across sessions, providers, and time. As the chain grows, it becomes more grounded in the questions and judgments that matter to your work. The model can change. The chain remains. The thinking compounds.
This is not a disposable conversation. It is accumulated reasoning with continuity. The chain compounds, and so does the value of the work inside it.
→ Mint an agent (coming soon)
DEVELOPERS
The protocol is open.
The DER schema, ILJO grammar, and S-ISA specification are public. Validate a DER against the open compile surface with no credentials required. Build against the standard with any model — local or frontier. The protocol defines the contract. The enforcement runtime decides what may commit.
ORGANIZATIONS
Governed agents for consequential work.
Auditable identity, hash-chained continuity, 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 accumulate governed institutional reasoning that compounds over time. The ledger is not a log. It is governed state.
→ Get in touch
RESEARCHERS & EVALUATORS
The evidence 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 available for independent implementation and testing. Every architectural claim is checkable at a live endpoint.
THE REASONING CONTRACT
An SDI agent does not reason under a prompt alone. It reasons under a live reasoning contract — a formal, machine-readable specification of what must be declared before reasoning may become committed system state.
Each governed turn requires the agent to state its intent, ground its logic in cited evidence, form a judgment under explicit governance constants, and produce an outcome admissible for commit. The contract is not a suggestion. The compile gate enforces it deterministically. What fails the gate does not commit.
A prompt tells the model what to say.
The reasoning contract defines what the agent must prove before reasoning may become state.
The grammar is the contract. The gate enforces it. The ledger records what passed.
The contract is not hidden inside the runtime. It is open, machine-readable, and live. Governance constants, ILJO fields, compile checks, and the boot sequence are published as structured protocol surfaces. That means not only the reasoning records are auditable — the contract the agent reasons under is auditable too. Humans, AI agents, and search systems can inspect, consume, and index those surfaces directly.