STRUCTURED DECISION INTELLIGENCE
Check the machine's reasoning yourself, not just its answer.
SDI is an open specification for a reasoning computer. A machine built to it is a Reckoner.​
​
​A Reckoner is a computer, not an AI model. Models work inside it and do the generating, but they hold no authority: a model cannot commit anything. A person drives. The model generates. The gate decides. The kernel writes. Every admitted reasoning act becomes a permanent, checkable record that later reasoning can build on or challenge.
One turn through a Reckoner: a person asks, the model proposes, the compile gate decides, and the kernel writes what is admitted. The record informs the next turn.
​
§ 01
Definition
What SDI is
SDI's invention is a language, Algebraic Decision Syntax. A model writes its reasoning in ADS, and a deterministic gate computes it. Same text, two readers, no translation layer. Write outside the grammar and the gate refuses it. SDI specifies that language, a protocol that decides what becomes state, and a computer that runs both. A machine built to the full specification is a Reckoner.
PARTS AND AUTHORITY
PART
WHAT IT DOES
AUTHORITY
Operator
Asks the question and commissions each act. Reviews any act the gate holds for a human.
Drives the machine
Model
Generates. Proposes each reasoning act in ADS. Any compatible AI model can fill this role.
None. It cannot commit anything
Compile gate
Checks each proposed act under fixed rules, safety first.
Decides what is admitted
Kernel
Runs each turn in order and verifies the agent's identity.
The only writer to the ledger
Ledger
Append-only, hash-chained record of every admitted act. A Reckoner's ledger is also called its chain.
The record of state
The index, the graph, and the chat interface read the record; none of them can change it.
Where the AI sits. Models power the generative steps inside a Reckoner: framing the question and authoring the reasoning act in ADS. None of those steps can change state. The gate decides admission and the kernel writes the ledger. A Reckoner can use any compatible model, and one chain can hold acts generated by many.
​
The reasoning act. Each act expresses how evidence bears on a question and how a judgment follows. That interpretation is preserved in a Decision-Evidence Record, or DER. Later acts can examine its claims, challenge their grounds, and carry the resulting understanding forward. The governed reasoning act is the computing primitive: what the machine admits, stores, and operates on.
​
The language. ADS, Algebraic Decision Syntax, gives that act its form. Intent establishes the question. Logic breaks it into sub-questions and connects each to evidence. Judgment combines their resolutions under a declared rule. Outcome records the result.
​
Formally, ADS is a declarative, defeasible, nonmonotonic, evidence-grounded, kernel-evaluated language that is deliberately not Turing-complete. Declarative: an act states judgments and relations; it issues no instructions. Defeasible: any claim can be defeated by a later act, because every claim has an address a later act can name. Nonmonotonic: new evidence can take away a conclusion's standing, and nothing is deleted when it does. Evidence-grounded: a claim that carries weight must cite real retrieval before it is admitted. Kernel-evaluated: the model writes ADS and the gate evaluates it, so the author and the judge are different parties. Not Turing-complete: the language has no loops or recursion, so the gate always reaches a verdict.
​​
​An algebraic sub-question carries a named term, a comparison, and a threshold. The retrieved value determines whether that condition is met.
​
​Question: in the head-to-head trial, did tirzepatide produce at least 5 percentage points more weight loss than semaglutide?
The sub-question that tests it:
pubmed.surmount_5_head_to_head_difference_pct >= 5.0
reported: 6.5 MET
​
The comparison establishes that the reported value clears this threshold. The complete act also preserves why this condition matters to the question, which evidence supplies the value, and how this finding contributes to the judgment. That relationship is the interpretation embodied in the DER. The predicate is one computable part of it.​​
​
The record remains readable and verifiable without a model. A model is required to generate new reasoning acts.
How it differs. A Reckoner is often compared to tools that sit beside a model. It is the computer the model runs inside.
HOW IT DIFFERS
OFTEN COMPARED TO
WHAT THAT DOES
WHAT A RECKONER DOES
A model wrapper
Adds an interface around a model. The model's output is the result
Runs the model the way an operating system runs a program. The model's output is a proposal, and only the kernel writes
A log or audit trail
Records what a model did, afterward
Decides whether a reasoning act is admitted at all, then seals it
Agent memory
Stores past outputs and feeds them back
Tracks each argument's standing. Defeated reasoning returns marked, to be engaged or overturned, never rebuilt on.
A guardrail
Filters a model's output
Requires the reasoning in a checkable form before anything commits
A model's explanation
Describes the reasoning afterward, in prose
The reasoning is the record: typed conditions, cited evidence, a declared judgment
Retrieval over a database or knowledge graph
Lets a model read structured knowledge and write conclusions back
Keeps the reasoning itself as state the machine goes on operating on
A living argument, not an archive. Every admitted act is an argument resting on claims. Later acts test those claims: they cite them, confirm them, or contradict them. A claim that holds strengthens everything built on it. A claim that is defeated takes its argument down with it, and it returns to later reasoning marked as defeated: something to engage, never a foundation to build on. New evidence can overturn a defeat and reinstate the claim, and that overturning is itself on the record. Nothing is ever erased: the record keeps every test, so an argument's standing is earned, never assumed. Most of a young chain is untested, and the record says so.
​
Take the model out. A wrapper is empty. A Reckoner still has its language, its gate, its ledger, and its graph. The record stays readable and checkable with no model running, and every verdict in it can still be re-verified. Only new turns need a model. Swap in a compatible model and the next turn continues from the same record.
§ 02
Problem
What it addresses
SDI addresses three practical needs: inspecting the reasoning behind a decision, controlling what a model's output is allowed to change, and retaining the work that produced it.
​
The first is trust. An answer alone does not show which evidence mattered, how it supported the judgment, or what would cause that judgment to change. SDI preserves those relationships in the governed act. An operator can inspect the derivation, check the published calculations and hashes, and follow later examinations of its claims.
​
The record also participates in the machine’s operation. Earlier judgments become available to subsequent acts, with their standing derived from the history of examination. Accountability extends beyond explaining a single answer to tracking how the system’s position develops.
​
The second is control. A model can generate reasoning, but it cannot admit its own output. The gate decides admission under fixed rules, and safety checks run first. Changing the model does not move the controls.
​
The third is ownership. Reasoning done for an organization can accumulate into intellectual capital: decisions with their grounds attached, findings tested over time, and a record of what changed and why. SDI gives that work a durable form its operator can hold, inspect, and carry forward.
An operator can begin with a question. ADS supplies the reasoning structure, and relationships accumulate as acts cite evidence and examine prior claims. A complete domain ontology is not a prerequisite for beginning that work.
​
The reasoning state lives outside the model. Changing a compatible model preserves the agent’s identity and accumulated record, even though a different model may reason differently on the next turn. The operator retains the work already done, and the record remains independently readable and checkable.
VERIFIABLE
The inputs, the governing rule, and the outcome are readable after the fact, and each record is sealed so a third party can recompute it without trusting the source.
STANDING
A claim that was examined and defeated is marked on the record and stops informing new reasoning. The original act is never edited; what changes is where it stands.
REPLAYABLE
The chain establishes what occurred, not what would occur again. It replays from its first act: what was surfaced, what was cited, what was decided, in order.
PORTABLE
The chain belongs to the operator. It is readable without the vendor that produced it and without any model at all.
§ 03
Mechanism
How it works
Four components share one reasoning grammar and have distinct responsibilities. The model proposes an act. The gate decides whether it meets the conditions for admission. The ledger preserves what is admitted. The graph derives each argument's current standing and helps select prior reasoning for subsequent turns.
​
The kernel coordinates the process, verifies the agent’s identity against its registered hash before the turn begins, and holds sole authority to write to the ledger. The reasoning act remains in ADS as it moves through proposal, validation, storage, and later use.
​
​An application calls a Reckoner as its reasoning runtime. The kernel runs the turn in order: it frames the task, retrieves evidence, invokes the model, and applies the gate. If the gate admits the act, the kernel writes it to the ledger. The application receives an answer with a reference to its record. The accumulated reasoning stays with the operator and informs subsequent turns.
The model
PROPOSES
The model proposes a reasoning act in ADS: an answer, its derivation, and the evidence supporting it. When new evidence conflicts with a prior claim, the proposal identifies the claim and addresses the conflict on a named basis. The model supplies the interpretation and judgment. It has no authority to commit them.
The compile gate
DECIDES
The compile gate evaluates the proposal through a fixed sequence of checks. Safety checks run first, followed by scoring and structural requirements, including evidence provenance. Each failed requirement can prevent admission. Passing establishes conformance to those checks. It does not establish that the conclusion is true.
​
A governance failure names the defect and returns the proposal for correction. A safety decision can stop the turn or require authenticated human review, according to the applicable rule. Safety refusals are retained in a separate hash-chained log. Only an act that satisfies the admission requirements can enter the ledger.
The ledger
RECORDS
The ledger preserves every admitted act in an append-only, hash-chained record. Corrections and subsequent judgments enter as new acts. They never overwrite the original. An act sealed at sequence 300 remains available in its original form as the chain grows.
The graph
MAINTAINS
The graph derives each argument's standing from the ledger’s citations and recorded examinations. It distinguishes arguments that remain untested, arguments that held under scrutiny, and arguments that were defeated. Later examinations can change that standing while the original acts remain intact.
​
The kernel uses the graph to select prior reasoning for subsequent turns. A defeated argument remains available for inspection but no longer serves as a standing premise for new reasoning.
​
The graph is derived from the ledger and can be rebuilt from it under the published rules.
§ 04
Graph
What a Reckoner becomes
Identity is assigned at commissioning. What the Reckoner comes to hold develops through its work.
​
Two Reckoners using the same model, one working on tax policy and another on maritime law, accumulate different evidence, judgments, and histories of examination. Their later reasoning draws on those differences. The model supplies inference; each Reckoner’s record gives that inference a particular history to work from.
​
Each question submitted for an ADS reasoning act gives the machine an opportunity to extend its state. An admitted act adds a judgment with its evidence and derivation, creating something later acts can read, use, and examine. Over time, those relationships build the structure this particular machine reasons from.
​
The accumulation has a computational role. As lines of code build a program, governed acts build a Reckoner’s body of reasoning. Those acts supply premises and resolved questions for subsequent work.​
​
The chat interface lets you converse with the Reckoner about its accumulated reasoning. Submitting a question through ADS puts it through the governed process that can extend that reasoning. You can explore what the machine holds, then commission the next act that develops it.​
​
Chromite is the public example, commissioned to reason about SDI itself. Its record lets anyone inspect how its positions developed, check the published hashes and calculations, and follow the arguments behind later revisions. Claims can be formally challenged through governed acts under the network’s rules. When an examination reveals grounds for changing the protocol, the case for that change has a permanent, inspectable history.
§ 05
Proof
Inspect it
Chromite is a live Reckoner built on SDI. Its chain is public and any act on it can be pulled and verified independently. It is here for one reason: to show the protocol behaves as described.
​
Chromite's chain holds acts generated by six different models, admitted through one gate onto one chain.
Acts from seq 400 forward are the current protocol. Earlier acts are real and readable, but the specification has been refined since, and older records will not carry every field described on this page.
Pull an act and you get the reasoning in order: the question as framed, each sub-question resolved against cited evidence with a stated threshold, the judgment composed from those resolutions, and the compile record, signed and hashed.
Pull the graph and you get the other half: which claims have been examined by later acts, which were held, which were defeated, and on what named basis.
§ 06
Protocol
Open for examination
Open here means three things.
​
Open reasoning. Every act is written in ADS, a form that carries its own evidence, logic, and judgment. The reasoning is readable as written. It is not a summary produced afterward.
​
Open protocol. The specification, the syntax, and the gate's rules are published on this site. Anyone can read what governs a Reckoner before running one.
Open to challenge. Chromite is SDI's public Reckoner. Its chain is fully inspectable, and it reasons about the protocol itself. Any Reckoner can author a defeat against one of its claims under the same requirements that govern every act. The result, held or defeated, stays on the record.
A Reckoner's own chain is private. Every Reckoner can also reach one public chain, the Reckoning. What is published there is permanent. A published act becomes available to every participating Reckoner to cite, build on, or challenge.
§ 07
Network
The network
The Reckoning is a shared public chain. It is maintained the way a single Reckoner's graph is: acts are cited, held, or defeated, and standing changes as later acts examine earlier ones.
Any Reckoner can cite what it finds there. An act cited from the Reckoning is treated as reasoning other agents have already tested in the open. It is not treated as a primary source.
Publishing is a choice. An operator can publish an act from a private chain so other Reckoners can cite, build on, and challenge it. The act stays on the private chain. A second entry on the network chain carries its hash, so the two chains are cryptographically tied and neither is subordinate.
Reach on the network is earned by citation and by holding under examination. Chromite holds no privileged position. Any Reckoner can challenge its claims under the same rules, and it can challenge theirs. Over time the record shows which agents' reasoning the network has relied on.
§ 08
Standards
Where it fits
Three public efforts name the problems SDI is built around.
​
NIST. The Center for AI Standards and Innovation launched the AI Agent Standards Initiative in February 2026. Related NIST work covers agent identity and authorization, agent security, and the monitoring of deployed AI systems. SDI's design addresses each: identity sealed into every record, authorization checked before a model is called, and a record written in a form built to be audited.
​
EU AI Act. Article 12 requires high-risk AI systems to support automatic recording of events over their lifetime. SDI's append-only chain provides a foundation for that traceability. Whether it covers a particular deployment's obligations depends on that deployment.
​
ISO/IEC 42001. The standard covers an organization's AI management system. A Reckoner contributes a record auditors can recompute. Conformity also depends on how the organization governs and operates the system.
​
Governance in SDI is gating. The gate decides whether a proposed act may change the machine's state at all. It does not inspect afterward. What is governed is the reasoning act itself, written in ADS.
​
An earlier version of the specification was submitted in March 2026 in response to NIST's Request for Information on security considerations for AI agents, docket NIST-2025-0035. A docket submission is public participation. It is not a review or an endorsement.
​
This is SDI's own assessment of alignment. It is not certification
Index
Explore
01
How verification works.
02
Step by step, from any machine.
03
What is fixed by the protocol,
and why.
05
Named, current requirements from NIST, the EU, and ISO, answered directly.
07
Roots of the system
04
The mechanisms that make the guarantees hold.
06
The live, machine-readable contract.
08
Reach the maintainer.