XODE Sentinel — Making Automated Decisions Verifiable
Gene Son ·
Automated decisions are easy to make. Proving exactly what happened afterward is harder. XODE Sentinel creates a cryptographic receipt for every decision, anchors the proof to the chain, and gives users a way to verify the record without simply trusting the operator.
The question Sentinel answers
When an automated system rejects a reward, blocks an account, or applies a policy, users usually have only one option: trust the system's explanation.
Sentinel changes that relationship. Instead of asking users to trust an internal log, it gives them a record that can be independently checked.
OLD MODEL
Trust the operator
The operator makes the decision, stores the evidence, and explains the evidence. The user must trust the same party at every step.
SENTINEL MODEL
Verify the evidence
The decision becomes a cryptographic receipt and is anchored to XODE so the historical record can be independently verified.
The October 1 case
On October 1, 2026, Omni rejected 166 advertising rewards because of cooldowns and 37 because of daily limits.
The users had watched the ads, Google had confirmed the views, and revenue had been generated. The important question was how to prove exactly which decision was made and whether that record could later be changed.
The evidence should not be controlled exclusively by the party asking you to trust it.
How Sentinel works
Every automated decision receives a fingerprint. The wallet, outcome, reason, policy, and timestamp are normalized into a deterministic record and converted into a cryptographic hash.
Those fingerprints are collected into an hourly Merkle tree. The tree produces one root, and changing even one fingerprint changes the resulting root.
That root is then submitted to XODE using System.remark_with_event. From that point, the historical commitment cannot simply be rewritten by the operator.
01
Fingerprint the decision
Normalize the wallet, outcome, reason, policy, and timestamp into one deterministic record and generate its cryptographic fingerprint.
02
Build the hourly Merkle root
Combine individual fingerprints into a Merkle tree. If even one fingerprint changes, the resulting root changes.
03
Anchor the root to XODE
Submit the root to XODE. The public chain becomes the external commitment to the historical record.
Only closed time windows are submitted. An open time window could later be invalidated by a decision arriving late. A submission that can still be rewritten proves nothing.
Users can verify without us
Users receive a receipt and a verification script that they can run on their own computer.
The script uses standard libraries and public RPC data. It does not ask the XODE application server whether the verification is valid.
The verification process answers two separate questions.
01
User dispute
The user reports that an advertisement was completed but the reward was not received.
02
Support lookup
Support locates the relevant receipt using the administrative lookup.
03
Receipt handoff
The receipt and independent verification script are provided to the user.
04
Run it locally
The user runs the verifier on their own computer using standard libraries.
LOCAL CALCULATION
Does the record belong to the root?
The verifier reconstructs the proof locally and checks whether the user's record belongs to the recorded Merkle root.
PUBLIC RPC
Does the root exist on-chain?
The verifier checks public RPC data to determine whether that exact root exists on the XODE blockchain.
If both checks pass, the decision is recorded as-is and the fact that it was recorded is publicly anchored to the chain.
Support does not need to explain the decision instead of providing evidence. Verification runs on the user's computer, and our server does not participate in that calculation.
Post-hoc manipulation becomes immediately detectable
Changing a rejection into an approval, modifying the reason, timestamp, target wallet, policy, or evidence causes verification to fail.
During testing, all 10 tested fields were modified individually, and all 10 modifications were detected.
ORIGINAL
Receipt matches the root
The original decision produces the fingerprint that was included in the committed Merkle root.
TAMPERED
Receipt no longer matches
Changing a protected field produces a different fingerprint and causes verification to fail.
If history changes, the proof should change with it.
"Which rules existed at the time?" is also recorded
Every record contains a policy hash. This is not a manually maintained version number.
The hash is automatically calculated from the actual configuration that was active when the decision occurred.
For example: 60 daily attempts · 180-second cooldown · 200/50 monthly cap.
If the limits change later, the policy hash changes as well. This means the rules that applied when a user was rejected cannot simply be hidden afterward.
Manual version numbers are intentionally avoided. A version number that someone forgot to update is worse than having no version number because it can become a false claim about what the system actually used.
What Sentinel is not
It does not prevent hacking. The chain does not make AI impossible to hack. It does not prevent prompt injection. Those protections are handled separately through hard guardrails built into the in-app AI.
It does not prove that the decision was correct. Sentinel proves that the record was not changed. Because the policy hash is also recorded, the rules themselves can be audited separately.
These two claims must remain separate: an immutable decision is not automatically a correct decision.
The verifier does not perform SCALE decoding. In exchange for running without additional libraries, it finds the root bytes directly in the block.
Anyone who wants stricter verification can inspect the same block using substrate-interface or a block explorer and find the same bytes.
What value does it add?
Area Today After Sentinel Reward disputes "Please trust our logs." "Verify it yourself." — Receipt + verifier provided Regulatory oversight No audit trail for automated decisions Historical decisions can be presented as immutable records Farming enforcement Explain why the user was blocked Enforcement decisions carry verifiable evidence Corporate trust Internal logs are the only record Public chain record that anyone can inspect
In the Philippine SEC and BSP environment, one potential question is whether automated decisions have an audit trail.
There is a difference between answering that question without such a system and being able to demonstrate that the system is already operating.
Expansion path
Sentinel currently starts with advertising reward decisions because that is where disputes are most common.
The same structure can later cover farming flags, device verification results, and AI assistant responses by changing the record's kind field.
When recording AI responses, the system can also preserve which model produced the response and which policy text governed it.
01
Advertising rewards
Preserve the reason and policy behind reward approvals and rejections.
02
Farming enforcement
Create verifiable evidence for automated farming and abuse decisions.
03
Device verification
Preserve the outcome of device identity and verification checks.
04
AI responses
Record which model responded and which policy governed an AI answer.
Current status
The collector is live in production. New reward decisions are being added to the ledger as they happen, and the reward logic itself has not been changed.
Component Status Decision collector Live — recording real advertising reward decisions Normalization · Merkle tree · proof Tests 41/41 passed Independent verifier Tests 19/19 passed Hourly submission timer · public receipt API Awaiting deployment On-chain submission Waiting for submission account funding
Of the 60 tests, the most important are not round-trip tests but tamper detection.
The system has been tested against changing a rejection to an approval, manipulating the reason, policy, timestamp, target wallet, replacing evidence, and downgrading the schema.
One more test is critical: Do the collector and independent verifier produce identical normalization bytes?
If these two systems disagree, every receipt already issued could become impossible to verify. This is one of the most serious failure modes the system could experience, which is why it is being tested directly.
The bigger idea
Sentinel is not designed to make users trust automated systems more. It is designed to make unnecessary trust less important.
Every decision becomes a fingerprint. Fingerprints become a Merkle root. The root becomes an on-chain commitment. And the user receives a way to independently verify the result.
Don't ask users to trust the record. Give them the receipt, the proof, and the chain.