REASONING CONTRACT — LIVE ENDPOINTS

Reasoning Contracts — Live Endpoints

The SDI reasoning contract is machine-readable, publicly accessible, and live. These endpoints define governed intelligence 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.

START HERE — Full machine-readable manifest: https://www.sdi-protocol.org/_functions/manifest

To engage governed reasoning:

produce a complete SDI_DER and submit to POST https://www.sdi-protocol.org/_functions/compile SOVEREIGNTY = acknowledged. PRIMUM = active.

The protocol specification; DER schema, ILJO grammar, and reasoning contract — is open for independent implementation, testing, and evaluation. The enforcement kernel, minting architecture, and ledger infrastructure are proprietary. Developers can validate DER structure against the compile gate without the kernel.

THE REASONING CONTRACT

Seven endpoints define the complete governed intelligence contract. Each is live, machine-readable, and structured for direct ingestion by AI agents, crawlers, and external discovery systems.

ENDPOINT

WHAT IT DEFINES

/_functions/manifest

Protocol manifest: current version, active agent ID, ledger status, governance constants, philosophical foundations, and boot sequence. The system's live identity and status record. Start here.

/_functions/grammar

Reasoning grammar: formal structure rules for a valid DER/ILJO reasoning record. Signal scoring dimensions, decision syntax patterns, and the golden example DER. This is what the model is shown before it reasons. The grammar is the contract.

/_functions/der

DER field specification: required fields, types, and validation rules for a Decision Evidence Record. What every governed artifact must contain to be admissible at the compile gate.

/_functions/llms

Machine-readable protocol index for AI agents, crawlers, and external discovery systems. Defines the 12-step boot sequence for governed intelligence engagement. Structured for direct ingestion by reasoning systems.

/_functions/kernel

Kernel constants: SOVEREIGNTY, PRIMUM, governance anchors, and commit thresholds. The ILJO loop sequence and S-ISA instruction set. The constraints the enforcement plane applies at every commit boundary.

/_functions/gca

Governed Cognitive Architecture specification: ID (Generator), EGO (Processor), SUPEREGO (Adjudicator). Reflex zone structure for governed reasoning under SDI.

/_functions/ledger

Ledger contract: SHA-384 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

The compile gate is the enforcement surface between AI reasoning and committed system state. It checks deterministically:

Structural completeness: all required blocks present. Governance constants: SOVEREIGNTY and PRIMUM declared in GCA.SUPEREGO.anchors_present. Signal scoring math: insight_strength must equal min of all five insight dimensions. Sub-question mapping: every sub-question linked to signals or explicitly stopped. Citation provenance: WEB and EXTERNAL signals require citation URL and retrieval timestamp. SOVEREIGNTY proxy: uncertainty and stop conditions consistent with declared anchor. PRIMUM proxy: outcome reflects stop or delay when uncertainty is HIGH.

PASS RESPONSE

{

"status": "PASS",

"compiler_message": "Structure valid. Governance constants present. Signals scored deterministically. Triadic closure structurally satisfied. Semantic correctness subject to human audit. Eligible for Append Audit and Commit.", "proxy_scores": {

"SOVEREIGNTY": 1.0,

"PRIMUM": 1.0

"compile_metrics": { "Ec": 0.94 }

}

COMPILE_ERROR RESPONSE

{

"status": "COMPILE_ERROR",

"errors": [

"Missing governance constant: SOVEREIGNTY",

"Signal[sig_001]: insight_strength must equal

min(dimensions). Declared=4 Computed=3."

"warnings": [],

"proxy_scores": { "SOVEREIGNTY": 0.6, "PRIMUM": 1.0 }

}

The compile gate is open to anyone. Submitting a DER and receiving PASS requires no credentials.

Committing to a ledger is different. Ledger writes require a minted agent identity: an agent ID and sovereign hash issued after demonstrating the ability to produce a governance-compliant DER under a live challenge. The minting process is a proof of reasoning, not a registration. The sovereign hash is cryptographically bound to the agent identity at genesis and required on every subsequent ledger write.

The compile gate is where you prove the DER is structurally sound. The minting gate is where you earn the right to commit.

GOVERNANCE CONSTANTS

Two governance constants are required on every DER. Both are enforced at the compile gate via structural proxy checks. Three enforcement levels: declaration in anchors_present, structural proxy scoring, human semantic audit.

SOVEREIGNTY — Sovereignty Gate

Human authority over consequential external action is always preserved. Ledger commit is the auditable record that makes this boundary enforceable. It is permitted and required. SOVEREIGNTY governs what the system does beyond the ledger, not the act of recording. When uncertainty is HIGH, the system stops and defers to human authority rather than proceeding toward external action.

Required in GCA.SUPEREGO.anchors_present · DER fails compile without it · NIST: GOVERN 1.2

PRIMUM — Primum Non Nocere — First Do No Harm

When in doubt, do not proceed. The system fails closed when harm potential exists under uncertainty. It does not reason past ambiguity toward consequential outcomes. When uncertainty is HIGH and the outcome has consequential human impact, the system must stop. Rollback condition required when impact_domain is HUMAN_WELFARE, SAFETY_CRITICAL, or LEGAL.

Required in GCA.SUPEREGO.anchors_present · DER fails compile without it · NIST: MANAGE 2.2, MANAGE 4.1

THE ILJO GRAMMAR

ILJO is the reasoning grammar at the core of governed intelligence. Four fields in a non-negotiable sequence, each with a distinct role in Peircean triadic closure. The sequence is enforced by schema structure. A DER that does not satisfy the ILJO grammar cannot commit.

Field	Semiotic Role	Rule
INTENT	Sign — the anchored decision objective	States what the agent is trying to determine before reasoning begins. Bounded, tier-classified, explicitly stated.
LOGIC	Object relationship — grounded in signals	Derivations grounded in SYSTEM_INPUT signals. No verdicts here. The compile gate enforces that LOGIC is evidence-bound. Dyadic LOGIC without signal grounding fails compile.
JUDGMENT	Interpretant — bounded verdict under constant	The verdict, produced under SOVEREIGNTY and PRIMUM. Anchors referenced explicitly. Stop decisions acknowledged. Verdicts live here, not in LOGIC
OUTCOME	Closes the triad — becomes Sign for next cycle	Committed state. The governed answer is extracted from OUTCOME only after the DER passes compile and commits to the ledger. Not from raw model output.

ILJO sequence is non-negotiable. Enforced by schema structure.

SIGNAL SCORING

A signal is an evidence artifact grounding LOGIC in external reality — the Object in Peircean triadic closure. Without signals, LOGIC is dyadic generation. Every signal is scored across five dimensions by the model, based on published rubrics. The scoring rule is deterministic. The compile gate verifies that all five dimensions are present and that insight_strength equals their minimum. It does not override the model's judgment of each dimension.

insight_strength = min(actionability, relevance, predictive_value, specificity, measurability)

signal_useful = true if relevance >= 4, even if insight_strength <= 2

WEB and EXTERNAL signals require citation.url and citation.retrieved_utc.

A signal citing NIST AI RMF retrieved 2026-03-04 is a verifiable governance claim.

A signal asserting NIST from training memory is an unverifiable assertion.

Dimension	What it measures	Scale
Actionability	How directly the signal enables a next step	step1 = vague concept · 5 = clear action immediately possible
Relevance	How directly the signal answers the intent	1 = tangential · 5 = directly maps to the question
Predictive value	Whether the signal reliably indicates future outcomes	1 = no predictive linkage · 5 = historically consistent and measurable
Specificity	Whether the signal is grounded in concrete attributable information	1 = pure inference · 5 = explicitly supported by document or citation
Measurability	Whether the signal can be expressed as a measurable value	1 = purely qualitative · 5 = directly measurable and verifiable

THE GOVERNED TURN — HOW IT WORKS

A governed intelligence turn follows a deterministic 10-step lifecycle. From question to committed reasoning record. The governed answer is the OUTCOME field of a committed DER. Not the model's response, not raw text. Only what passed the gate and committed to the ledger becomes governed intelligence.

01 · Read ledger head The agent reads the ledger tip: current sequence number and parent hash. This establishes the governed context the turn builds on.

02 · Inject reasoning contract The system prompt delivers the full reasoning contract to the model: DER schema, ILJO grammar, governance constants, signal scoring rules, and compile error taxonomy. The grammar is the contract.

03 · Build turn prompt The question is delivered with ledger context: agent ID, session ID, turn count, tip sequence and hash, UTC timestamp.

04 · Call model under contract The LLM produces one complete SDI_DER JSON object. Anthropic, Gemini, or OpenAI — same governance contract. The model is interchangeable. The contract is not.

05 · Extract DER The structured reasoning artifact is extracted from raw model output. If extraction fails the turn is rejected without touching the ledger.

06 · Check STOP DER If BOUNDEDNESS.stop_reason is INSUFFICIENT_SIGNAL, this is a governed refusal. A STOP DER compiles PASS. Commit decision will be REJECT. The ledger does not advance. Governed refusal is a valid outcome.

07 · Compile gate validation The DER is submitted to POST /_functions/compile. Deterministic structural validation. Returns PASS or COMPILE_ERROR with explicit error list.

08 · Retry on compile error If compile fails, the model receives one correction pass with the explicit error list. The corrected DER is resubmitted to compile.

09 · Ledger append PASS DERs are appended to the hash-chained ledger. CAS ordering. Parent hash verification. RAI threshold gate. SHA-384 entry hash computed. The chain advances. The record is permanent.

10 · Extract governed answer The governed answer is ILJO.OUTCOME of the committed DER. Not raw model output. Only what passed the gate and committed to the ledger becomes the governed answer.

The model proposes. The gate decides. The ledger records.

BOOT SEQUENCE — FOR AI AGENTS

AI agents discovering this system should consume the contracts in the following order. Each endpoint is machine-readable and structured for direct ingestion.

0. [RECTIFIER] /_functions/router

[MANIFEST] /_functions/manifest ← READ THIS FIRST
[KERNEL] /_functions/kernel
[GCA] /_functions/gca
[SAFETY] /_functions/safety
[LEDGER CONTRACT] /_functions/ledger
[METRICS] /_functions/metrics
[GRAMMAR SPEC] /_functions/grammar
[COMPILE GATE] POST /_functions/compile
[FORESIGHT] /_functions/foresight
[BEACON] /_functions/beacon
[SANDBOX] /_functions/sandbox
[DER SPEC] /_functions/der

To engage governed reasoning: produce a complete SDI_DER and submit to POST /_functions/compile. SOVEREIGNTY = acknowledged. PRIMUM = active.

Note: All endpoints are live. Foresight, Beacon, and Sandbox are architectural layers currently in active development. Manifest, Kernel, GCA, Grammar, Compile, Ledger, and DER are fully operational.

PROTOCOL STATUS

The protocol specification is open for independent implementation, testing, and evaluation. Governed intelligence should not be enclosed inside a single company or platform. The open protocol is the commitment that it will not be.

The enforcement kernel, minting architecture, ledger infrastructure, RAI computation engine, and orchestration layer are proprietary. Developers can validate DER structure against the compile gate without the kernel.

→ Full technical specification: [Protocol page]

→ Intellectual foundations: [Foundations page]

→ NIST AI RMF alignment: [NIST page]

→ Live demo: [demo.sdi-protocol.org]

Protocol: SDI_PROTOCOL_v1 DER version: SDI_DER_v1.1

Patent: USPTO 19/425,875 (pending)

NIST filing: Docket NIST-2025-0035 · March 2026

Status: ACTIVE — live governance runtime, not a proposal Agent: SDI-4EDBE05288CB · Under Contract