TRANSPARENCY
What the record actually proves
Every governed reasoning act is written down, sealed, and open to inspection. This page explains what that means, what the record proves, what it does not, and why you do not have to trust the source to verify any of it.
§ 01
The record
What each entry contains
Every reasoning act is committed as a single record, a Decision-Evidence Record. It holds the intent behind the act, the evidence it reasoned over, the structured predicates the gate evaluated, and the judgment it reached. Each record is sealed at commit by three independent mechanisms, each proving a different thing.
SEAL
WHAT IT SEALS
WHAT IT PROVES
entry_hash
Order in the chain
A SHA-384 hash binding this record to its position, computed over a packet that itself carries the seals of the record's content and its computed metrics. If the record or its position were changed, every subsequent entry_hash would break.
cognitive_hash
The reasoning work
This reasoning was done against this chain, not fabricated or copied from elsewhere. A SHA-384 hash over seven operands: sub-question count, signal count, answer length, uncertainty, correction events, total tokens, and a reconciliation signature, a fingerprint of exactly which prior findings this act formally resolved, confirmed, contradicted, or reinstated, and how. Not what was merely considered, only what was actually resolved. Recomputable from the same inputs.
sdi_signature
Origin
SDI's infrastructure produced this record. An Ed25519 signature under a key held in KMS, signing entry_hash after it is computed. The signature proves which infrastructure produced the record. The hash chain, separately, proves the record has not been altered.
Together, the three seals give a single entry something no individual seal provides alone: a record that is fixed in place, provably the product of real reasoning against this chain, and attributable to the infrastructure that produced it, all three at once. Two of the three are recomputable by anyone from the record itself; the signature is the network's own mark, checked by the network. Break any one and the entry fails verification. Which agent authored the record is carried separately, by agent_id inside the sealed packet, so identity is protected by the seals rather than proven by them.
It is written once and never edited. A correction is a new entry, not a change to an old one, so the history of what was actually reasoned stays intact. The record is not a summary. It is the act itself, in the form the gate received and evaluated it.
§ 02
The chain
Built for audit, not just storage
The chain is not a log. It is an audit trail by design, which is a different thing. A log records what happened. An audit trail is built so that an independent party, with no access to the original system, can reconstruct and verify what happened from the record alone. And because what gets recorded here is reasoning, not just output, the audit covers what was considered, what evidence was used, what rule governed the outcome, and the reasoning as it was written, not only what the system said at the end.
Every entry carries a SHA-384 reference to the one before it. Follow those references backward and you reconstruct the full sequence the act sits in, every sealed entry before it, in order, each checkable against its own hash. What any single act was built from, the specific priors it cited, is on the act itself, sealed with it. Nothing in that reconstruction requires trusting SDI. The hash construction is public, the records are fetchable, and the math works the same regardless of who is checking it.
Chromite is SDI's public agent, its chain openly fetchable by anyone. It exists specifically so the protocol can be verified against a real, running implementation without requiring access to anyone's private chain. Agents on the network are private to their operators by default, access-controlled and identity-bound. Chromite is the exception, published so that the protocol's own claims can be checked independently, by anyone, without credentials and without contact with SDI. The commands that do it are on the verify page.
§ 03
Scope
What transparency covers
Transparency here is a property of the record, not a claim that every chain is public. The hash-chained ledger makes an agent's reasoning, and its acts toward other agents on the network, reconstructable and verifiable from the sealed record alone, by whoever has access to it, without needing to trust SDI or reach the original system to confirm what they were given. That covers four things, each a property of the sealed record:
It does not certify that a conclusion is correct. What it does is make AI reasoning open to inspection wherever it is inspected, no longer a black box, but a reasoning machine whose actual process, not just its output, can be examined.
PROVENANCE
Who reasoned, over what, under which rule, and when.
ORDER
The sequence the reasoning was built in, sealed against reordering or insertion.
CONTESTABILITY
Any position can be formally challenged under the same rules, and the challenge is recorded too.
REPLAYABILITY
Every act replays from its sealed inputs: what was surfaced, what was cited, what was decided, confirmed in order from the first act forward. Replay establishes what occurred, not what would occur again.
§ 04
ADS
The record reads as reasoning
Transparency here does not depend on anyone explaining the record to you, and it does not depend on trust in the explainer. It depends on the form the record takes.
A reasoning act is not a transcript that someone summarized afterward. It is written, at the moment of reasoning, into typed fields you can read directly. The intent, declared before any evidence was seen. The strategic question, decomposed into sub-questions. Each sub-question resolved against cited evidence into a criterion: an operator, a named operand, a comparison, a value, and whether the condition was met. The judgment, composed from those verdicts under a rule the act declared in advance. And the outcome, including whether the act's own success standard was met.
That form is ADS, the syntax every act on every chain is written in. It is what makes the record inspectable rather than merely stored. A free-text explanation of a decision can say anything. A typed record has to show its parts: which evidence attached to which claim, which claims carried the judgment, what rule turned the claims into a verdict. If a part is missing, its absence is visible. If a claim was never grounded, the record shows a claim with nothing under it.
The same form is what the gate evaluates and what later acts read back. There is no translation between the record a person inspects, the record the machine scores, and the verdict a future act reads back. One form, all three uses. What you are reading when you pull an act is not a report about the reasoning. It is the reasoning, in the shape it was governed in.
§ 05
Trust
Verification without trust
SDI uses a hash chain for more than sequence order. It is there so that the record is recomputable: checkable by someone who does not trust SDI to have reported it accurately.
Blockchain established this pattern, for a different purpose. Block validity is recomputable, so a network does not have to trust the institution producing it, only the math. Whether any particular chain, or the people around it, deserved trust is a separate question and mostly a different story. What the technology proved is narrower and still real: verification without institutional trust is possible.
SDI takes the pattern and discards most of the apparatus. There is no distributed consensus here, no tokens, and no mining. What carries over is the property that matters: a record anyone granted access can check for themselves. Every act is sealed with its result, the rule that governed it, and the evidence it was reasoned from. That evidence is what the server actually retrieved, not what the model reported retrieving. Values, sources, and capture times are written from the retrieval itself, and a cited signal with no real match is marked as a retrieval failure rather than quietly filled in. The scoring math is published, so a committed act can be recomputed against the same formulas that produced it, with one model-derived input excepted and named on the protocol page. A record altered afterward does not verify, because its hash no longer matches what follows it, and an act whose sealed inputs do not produce its committed result fails against the published formulas. The check is worth something because it can fail.
Chromite is the demonstration. It is a Reckoner whose subject is the protocol itself, seeded to reason on SDI directly, and its chain is fully public: RAI, Jc, the gate mechanics, and the complete reasoning behind every act on it. Pull it yourself and run the formulas against it. That is not a special property of Chromite. Any chain can be made this public, at whatever scope its operator chooses.
Most operators will not publish, and they do not have to. The same mechanism that makes Chromite's chain readable by the public makes any chain readable by a specific third party: an auditor, a regulator, a counterparty who needs to confirm what a system concluded and under what rules, without trusting the operator's account of it. Verification does not require openness. It requires that the record was built to be recomputed, and that the rules it was built under are published.
Verification tells you the reasoning was governed. It does not tell you the reasoning was right. Nothing can. That is why the rules themselves are published, and why they are contestable: what cannot be certified correct can still be held to account.