STRUCTURED DECISION INTELLIGENCE
Deterministic Governance Runtime for AI Reasoning
[ dCOS_KERNEL_ACTIVE ]
UTC 20260318 01:04:00Z
FOUNDATIONS
Why Governed AI Reasoning Requires a Protocol Layer
SDI is a governance runtime that separates what a model generates from what a system is allowed to commit. A model can propose. The protocol decides whether that proposal is structurally valid, admissible, and allowed to become durable system state. This page explains why that boundary must be enforced at the protocol layer - and why behavioral approaches alone cannot close that gap. For the full technical specification see the Protocol page. For cross-provider proof and NIST alignment see the NIST page.
THE STRUCTURAL PROBLEM
Modern computing was built on two foundational frameworks, each scoped precisely to the problem it was designed to solve.
Claude Shannon formalized information as signal transmission. In 1948 he explicitly scoped the engineering problem to exclude semantics - "the semantic aspects of communication are irrelevant to the engineering problem." Communication systems do not need to govern meaning, they need to transmit signals reliably. Shannon's framework did that, and it shaped decades of information architecture that followed.
Alan Turing operationalized machine intelligence in behavioral terms. The Turing Test asked whether a machine could produce output indistinguishable from human thought, a workable criterion for evaluating machine behavior at a time when no other criterion existed. It was scoped to evaluation, not to adjudicating truth, intent, or commitment.
"Frequently the messages have meaning — these semantic aspects of communication are irrelevant to the engineering problem."
— Claude Shannon, A Mathematical Theory of Communication (1948)
Large language models inherit both frameworks. They process signals and they are evaluated behaviorally. But they do something earlier computational systems did not: they operate in natural language, which carries meaning. Every output carries implication. The system is no longer transmitting signals between well-defined endpoints, it is generating meaning in an open-ended linguistic space, and that meaning may be acted on, trusted, or committed as system state.
That is a different problem. And it is not one that signal transmission frameworks or behavioral evaluation criteria were designed to govern.
AI architecture has advanced dramatically since 1950. Symbolic systems introduced explicit rules. Neural networks introduced statistical learning. Transformers introduced extraordinary fluency at scale. But none of these advances installed an admissibility protocol for reasoning at the commit boundary. The governance problem remained external, assumed to be a human responsibility, handled after the fact.
Modern computing inherits the tradition of mathematical logic; deterministic, closed, binary. Natural language reasoning inherits the tradition of semiotic meaning-making — contextual, interpretive, open-ended. These two traditions have largely operated in parallel. Symbolic AI tried to reduce reasoning to mathematical logic and lost meaning. Connectionist AI recovered meaning through statistical learning and lost deterministic governance.
SDI brings them into contact at the commit boundary. The DER/ILJO grammar uses Boolean and binary structures; EXISTS, THRESHOLD, BOOLEAN_CHECK, to evaluate whether meaning-bearing reasoning satisfies formal governance conditions. Natural language fills the semiotic fields: intent, logic, judgment, outcome. Mathematical logic evaluates whether those fields are structurally valid and admissible. The model reasons in natural language. The gate evaluates in formal logic. Governance lives at that junction — and the grammar is the mechanism that makes the junction computable.
THE MISSING PIECE — SEMIOTICS AND THE STRUCTURE OF MEANING
The study of meaning has two branches that matter here.
Semantics asks what words and expressions mean, the relationship between language and the world it refers to. Most AI governance thinking operates at that level: does the output mean the right thing, does it refer to the right facts, is the answer correct.
Semiotics asks something deeper: how meaning comes to exist at all, the structure by which a sign comes to carry meaning for an interpreter. Semantics takes meaning as given and analyzes it. Semiotics asks how meaning is constituted in the first place.
That distinction matters for governance. If meaning is a structured relationship between sign, reality, and judgment, then governance requires that structure to be made explicit, enforceable, and durable. That is a protocol problem, not an evaluation problem. Ludwig Wittgenstein’s later work, particularly Philosophical Investigations, argued that meaning is not a fixed property encoded in symbols but something that emerges from how language is actually used in practice. He called these patterns of use language games: meaning is constituted by the activity of using signs in context, not by a static mapping between symbol and referent.
Charles Sanders Peirce approached the same problem from a different direction. In the 1860s, he defined the semiotic triad: Sign, Object, Interpretant. For a signal to carry meaning, not just transmit, not just refer, but actually mean, all three must be present. The Sign is the symbol or token. The Object is the reality it refers to. The Interpretant is the meaning-bearing judgment that links them: the element that makes meaning possible rather than merely plausible.
Wittgenstein and Peirce arrive at a convergent conclusion by different routes: meaning cannot be fully predetermined by a static mapping alone. That shared insight points toward the same architectural consequence. If meaning is produced in context rather than simply retrieved from symbols, then governance requires governing the act of its production, not just the symbols involved.
Without the Interpretant, you may have reference, but not yet governed meaning. A system can map signs to objects and still leave unresolved the judgment that determines what that relationship means in a specific reasoning context.
The obvious objection is that symbolic AI systems, expert systems, knowledge graphs, formal logic engines - already use structured representations. In one sense, they do. They provide explicit symbols, rules, and defined relationships. But with respect to governance, they remain dyadic in operation: sign mapped to object, concept mapped to definition, term mapped to term. The meaning is largely predetermined by the map or rule set. It is retrieved or applied, not externally produced and governed as a distinct reasoning artifact.
That is what makes them brittle. A predefined mapping holds as long as the context remains close to the conditions under which the mapping was built. When context shifts, when a concept must be applied in a novel situation, under competing constraints, with consequences attached - the system can preserve correspondence, but it cannot by itself govern how that relationship should be resolved for commitment. And without a governed commit boundary, there is no structural mechanism preventing broken or unresolved reasoning from entering system state. The Interpretant is not the map. It is the judgment that gives the sign-object relationship meaning in a specific context, for a specific purpose, under specific conditions. That is a different class of operation: not representation, not correspondence, but governed judgment.
The brittleness of predefined symbolic mappings under novel conditions is well documented. The frame problem, first formalized by McCarthy and Hayes in 1969, describes precisely this failure: a system operating on predefined rules cannot determine what remains valid when context shifts in ways the rules did not anticipate. SDI does not claim to solve the frame problem generally. It addresses a specific instance of it: at the commit boundary, reasoning that cannot satisfy the governance grammar does not enter system state.
A similar objection applies to LLMs augmented with retrieval - web search, RAG, and live data feeds. Retrieval improves access to the Object: the model has access to current information rather than static training data. But retrieval does not formalize the Interpretant. The judgment that links retrieved information to a commitment still occurs inside the model, implicitly, without structural capture, admissibility evaluation, or a durable governed artifact. The grounding of the Sign-Object relationship improves. The meaning-producing act remains implicit and ungoverned. SDI addresses that second problem.
It does so through a grammar that is itself triadic in structure. The DER/ILJO contract requires natural-language meaning and algebraically evaluable admissibility conditions simultaneously in the same artifact. INTENT, LOGIC, JUDGMENT, and OUTCOME are meaning-bearing fields: contextual, interpretive, and open-ended. SUCCESS_STANDARD targets, DECISION_SYNTAX operators, and signal scoring dimensions are formally evaluable: deterministic, measurable, and gate-checkable. Symbolic systems preserve formal evaluation, but do not externalize the Interpretant as a governed artifact. LLMs produce natural-language reasoning, but leave the Interpretant implicit and ungoverned. SDI requires both in the same artifact, evaluated together at the compile boundary. The grammar is what makes the junction between natural-language meaning and formal admissibility computable. Neither alone closes the governance gap. Together they make the Interpretant not just expressible, but evaluable and enforceable.
Symbolic systems predefine meaning. Connectionist systems approximate it.
SDI governs the act of producing it.
The deeper issue is what Stevan Harnad called the symbol grounding problem in 1990: symbols in a formal system only refer to other symbols, they cannot by themselves derive meaning from the world they purport to represent. SDI's signal architecture addresses this directly. Every LOGIC field must be grounded in externally cited evidence; signals with provenance, citation, and retrieval timestamps. Reasoning that cannot be grounded in external reality does not pass the gate. The Interpretant is not allowed to float free of its Object.
The architectural mechanism behind that claim, the DER/ILJO contract, the compile gate, and the hash-chained ledger, is documented in the Protocol page and demonstrated live in the GlassBox demo.
FROM PHILOSOPHICAL ARGUMENT TO ARCHITECTURAL RESPONSE
Peirce's triad explains that structure of meaning. But in semiotic theory the Interpretant remains a cognitive effect, something that happens in a mind, not a system artifact that can be captured, evaluated, or enforced. The externalization of the Interpretant as a governed artifact is a design choice, not a conclusion Peirce's theory requires. But it is the design choice the philosophical argument points toward: if the Interpretant is the element that makes meaning possible, and if governed cognition requires that element to be explicit, enforceable, and durable, then externalizing it as a parseable system artifact is the architectural move that closes the gap. That is what SDI does.
The parseable artifact is the right form for the externalized Interpretant not because it captures the full richness of meaning but because it is the form that admits deterministic evaluation, the minimum structure required for a governance boundary to be enforceable.
SDI externalizes the Interpretant into a parseable syntactic structure — the DER/ILJO contract — and subjects that structure to a compile gate. The act of resolving meaning between sign and object is no longer invisible. It is captured as governed system state: structured, evaluated, accepted or rejected, and committed to the record. In theory, semiosis can remain open-ended. In a governed system, the gate provides operational closure at the commit boundary.
SIGN → The token · the word · the output
OBJECT → The reality it refers to
INTERPRETANT → The meaning-bearing judgment that links them
[ externalized in SDI as a parseable artifact ]
The ILJO structure operationalizes that externalization. Each field is required, computable, and enforced at the gate.
INTENT → Names the Object — what reality is being addressed
LOGIC → Grounds the reasoning — evidence-grounded derivation, no verdicts
JUDGMENT → Externalizes the Interpretant — the governed resolution
OUTCOME → Closes the loop — the committed artifact
A Decision Evidence Record (DER) that fails to satisfy all four fields does not pass the compile gate. The grounding is not optional. It is enforced.
THE GRAMMAR OF REASONING
When the Interpretant is externalized and enforced, it becomes something more precise than a judgment, it becomes a grammar. A grammar defines the syntactic rules that govern how a Sign can validly relate to an Object. Peirce left the Interpretant as a cognitive effect, something that happens in a mind. SDI externalizes it as a governed reasoning syntax: a machine-readable contract the model must satisfy before reasoning can become committed system state.
ILJO is that grammar. Intent, Logic, Judgment, and Outcome are not fields in a form — they are the grammatical rules of admissible reasoning. Here is what that means in practice:
MODEL OUTPUT ALONE
Output may be fluent, detailed, and confident.
But the reasoning that produced it is not inspectable —
even its makers cannot fully account for what happens
between input and output.
Confidence is not commitment. Model self-explanation is not a standard.
SDI-GOVERNED FORM
INTENT → What decision is being made
LOGIC → What facts and constraints support it
JUDGMENT → Why the decision is admissible
OUTCOME → What is committed and recorded
If any field is missing or malformed, the compile gate returns FAIL.
Each field is a syntactic constraint. A reasoning act that satisfies all four required fields, and the contract conditions attached to them, is structurally admissible. One that fails any field is rejected at the gate. A governed artifact must satisfy the required contract structure, warnings do not substitute for admissibility.
In that sense ILJO functions as a domain-scoped governance grammar: the system deterministically parses required reasoning structure and produces a binary accept/reject decision at the commit boundary. The grammar is not linguistic alone. It joins meaning-bearing fields in natural language to deterministically evaluable conditions; success standards, decision syntax patterns, threshold logic, and scored evidence requirements, so that reasoning is not merely expressed, but tested for admissibility. This is the critical distinction between SDI and a prompt library, text wrapper, or reusable template. Prompts can suggest structure. A grammar determines whether a reasoning act is admissible. In SDI, admissibility is defined by the DER/ILJO contract and enforced by an external compile gate. For the full technical specification of the grammar, production rules, and compile behavior, see the Protocol page.
Cross-provider validation matters because the same governance contract has been successfully imposed across multiple model providers, and each has produced output that conforms to the same admissibility structure at the commit boundary. That is evidence the grammar is portable and enforceable across providers. For the full proof record, see the NIST page.
Within SDI, unresolved reasoning does not become system state. It fails at the compile gate. That is how the system achieves closure at the commit boundary.
ILJO → The grammar of admissible reasoning
S-ISA → The syntax and contract specification
COMPILE GATE → The external enforcement boundary for admissibility
DER → The governed artifact produced when the grammar is satisfied
Each committed ILJO cycle also produces a hash-chained record, giving the system continuity, auditability, and a substrate for future governed memory. That is why the protocol layer achieves what behavioral constraints cannot: the grammar outlasts every instance it governs.
WHY A PROTOCOL — NOT A POLICY
Ashby's Law of Requisite Variety states that to govern a system of increasing complexity, the governing mechanism must have equal or greater structural stability. Behavioral approaches, RLHF, soft guardrails, and content filters modify surface outputs. They can shape what a model is likely to say. But they do not create a structural boundary between generated output and committed system state. Under sufficient pressure, novel framing, or distribution shift, behavioral controls degrade because they remain properties of model behavior, not of system admissibility.
Ashby's Law does not require the governance mechanism to match the full complexity of model generation. It requires the governance mechanism to be structurally stable at the boundary where generation becomes committed state. That boundary is the compile gate, deterministic, model-independent, and structurally invariant regardless of upstream model behavior.
BEHAVIORAL APPROACH → Modifies what the model says
PROTOCOL APPROACH → Controls what may become system state
A policy can describe what should happen. A protocol determines what can happen.
The TCP/IP parallel is instructive. The early internet operated without a universal protocol standard. When TCP/IP emerged, it became the governing layer, not because it made servers behave better, but because it defined a transport contract all systems had to conform to regardless of internal implementation. Many of the internet's enduring security problems stem from governance and trust controls being layered on after the core protocol rather than built into it from the start.
The same principle applies to machine reasoning at scale. If reasoning is to be governed across providers, agents, and contexts, governance cannot remain a model-local behavioral setting. It requires a protocol layer that defines what reasoning is admissible before it becomes committed state.
This is not only an architectural argument. The EU AI Act's requirements for high-risk AI systems mandate explainability, auditability, and human oversight as structural requirements, not post-hoc additions. External regulatory frameworks are converging on the same conclusion: governance must be built into the system, not layered on after deployment. SDI's architecture is designed to satisfy those requirements by construction, not by compliance retrofit.
The distinction between SDI and prior AI paradigms is not knowledge representation or learning mechanism. It is governance embeddedness, whether human oversight and failure-closure are structural invariants or post-hoc additions.
That is where SDI operates. The DER/ILJO contract defines the required structure of governed reasoning. The compile gate enforces admissibility at the commit boundary. The external logic node controls append authority to the ledger. Together, these create the structural boundary behavioral methods lack: a model may generate freely, but only governed reasoning may enter durable system state.
The protocol does not ask the model to behave well. A deterministic compile gate is not governed by model persuasion - it accepts or rejects based on structural conformance. That governance has been validated live across Anthropic, Google, and OpenAI under the same contract conditions. The LLM is interchangeable. The contract is not.
WHAT SDI IS NOT CLAIMING
These are the explicit boundaries of what SDI claims.
SDI DOES NOT CLAIM | WHAT SDI DOES CLAIM |
|---|---|
A formalization of human thought or cognition | A domain-scoped grammar for governed machine reasoning, enforced by a deterministic compile gate with binary accept/reject outcomes |
ILJO is the only valid reasoning structure | ILJO is a working governance structure with live cross-provider proof across three providers |
To change the model’s underlying weights or native architecture | To condition inference-time reasoning through a governed grammar and enforce admissibility at the commit boundary |
That the current demo represents the full SDI system | That the current demo is a live proof of the architecture — governed agent runtime, reasoning contract, compile gate, and hash-chained continuity demonstrated in practice across providers |
A complete cognitive operating system | The architectural foundation from which a governed cognitive OS can be built — the model is incorporated, not replaced |
Hallucination is fully solved | Structurally unsupported reasoning at the commit boundary is blocked by a deterministic gate |
Peirce's semiotic triad is formally sufficient for governance | The triad provides generative scaffolding — the compile gate provides the computable halting condition it lacks natively |
DESIGN PRINCIPLES
Five principles flow from the intellectual basis into the implemented system. These are not aspirational — they describe what the system enforces right now.
[01] GENERATION ≠ COMMITMENT
LLM output is a proposal, not a commitment. The model generates — the compile gate decides. Authority remains with the governing system. The LLM is subordinate to the protocol, not the other way around. Nothing becomes system state until the reasoning syntax compiles.
[02] STRUCTURE BEFORE OUTPUT
Most approaches filter, rank, or fine-tune after generation. SDI conditions the model before output is accepted. The DER/ILJO envelope is not a wrapper around output — it is the syntax the output must conform to before it exists as governed reasoning. The model writes to a grammar. The gate parses it.
[03] PROTOCOL LAYER GOVERNANCE
Governance lives not in model weights or post-hoc filters, but at the system boundary, where it is deterministically enforced. A compile gate cannot be prompted around. It does not interpret intent. It parses syntax and returns PASS or FAIL.
[04] IMMUTABLE AUDITABLE RECORD
Every committed artifact is a Decision Evidence Record — hash-chained, provider-stamped, and structured in protocol language. Not just a log, but a governed artifact. Auditable by any party with access rights and parsable at governance scale. Governance without a verifiable record is not governance.
[05] MODEL-INDEPENDENT GATE
The same compile gate has validated output across Anthropic, Google, and OpenAI models. The LLM is interchangeable. The protocol is not.
SDI is best understood as a distinct category of AI system defined by governance-as-architecture. Sovereignty, harm-closure, and bounded uncertainty are not design choices or runtime preferences, they are structural invariants enforced at the commit boundary. The grammar enforces them. The gate confirms them. The ledger preserves them.
The philosophical argument above motivates the design. It does not prove the design is optimal or complete. What the live system demonstrates is that the governance grammar is enforceable, portable across providers, and produces verifiable governed artifacts. The NIST submission, the public ledger, and the cross-provider proof record are presented as evidence of a working implementation, not as proof of a finished system. Serious review, critique, and independent validation are invited.
If reasoning cannot be made admissible, it cannot be safely committed. SDI is presented here as an open protocol and live demonstration of a protocol-layer approach to governed machine reasoning: requiring structure, enforcing a compile gate, and preserving continuity in a hash-chained record. The foundations above explain the design logic. The live system shows one working implementation of it in practice.