A NEW TRUST PRIMITIVE

Procedural Proof

The blockchain world has PoW, PoS, ZK, Optimistic fraud proofs.
None of them work for AI output.
We built the one that does.

Oracle is not a trust layer. It's procedural justice infrastructure.

The AI-on-chain trust paradox

AI output is non-deterministic. You can't prove it's "correct" — only that it followed a process. Every existing trust mechanism fails here.

PoW / PoS

Trust: computational or capital cost

ZK Proof

Trust: mathematical certainty

Multi-sig

Trust: identity and reputation

Consensus

Trust: redundant re-computation

Optimistic

Trust: fraud proof of computation

Procedural Proof

Trust: replayable process compliance

Why existing primitives fail for AI

ZK can't prove AI reasoning (non-deterministic).
PoS doesn't grant cognitive authority.
Consensus can't validate — re-running same AI ≠ same result.
Optimistic fraud proofs check computation, not judgment.

Procedural Proof solves it

Don't verify the conclusion. Verify the process.
Was a public SOP followed? Is the evidence immutable?
Can anyone replay the verification?
If yes → epistemic warrant sufficient for execution.

Four-layer architecture

Each layer has a single responsibility. Trust emerges from the combination.

Evidence

AI executes SOP, archives raw data to IPFS, commits hash on-chain. Immutable. Tamper-proof.

Verification

Independent verifiers audit evidence against public SOP. Mechanical, replayable. No domain expertise needed.

Distribution

On threshold met → LayerZero dispatch to any chain. One judgment, multi-chain execution.

Execution

Target chain receives verified conclusion → triggers contract action. Chain is a hand, not a brain.

"Going on-chain" is redefined: not "entering a chain" but "entering the verifiable world."
The chain is not the gate. The Oracle is the gate. Chains are rooms behind it.

Isomorphic to LayerZero DVN

We don't invent a new trust model. We replicate the one that already works — LayerZero's DVN (Decentralized Verifier Network) — and apply it to a different domain.

Dimension	LayerZero DVN	NEO Oracle
Immutable base	Source chain block state	IPFS evidence + on-chain hash
What's verified	Message transport integrity	SOP compliance
Verification method	Read source hash → compare	Fetch evidence → walk SOP checklist
Replayable by	Anyone with chain access	Anyone with IPFS access
Verifier selection	OApp chooses DVN set	Agent chooses Verifier set
Trust source	Cheating is detectable	Cheating is detectable

// The trust question in both systems:
//   NOT "do I trust this entity?"
//   BUT "can I catch them if they lie?"

DVN:     source_chain_hash == message_hash ? pass : slash
Oracle:  evidence_follows_sop(evidence, sop) ? pass : slash

// Same structure. Same security model. Different domain.

The third path

The standard oracle narrative offers two choices. We add a third.

Path 1

Trust institutions

Chainlink nodes, custodians, auditors. You trust they won't collude. Subjects can be bribed, coerced, replaced.

Path 2

Trust quantity

Enough nodes repeating the same thing. But for off-chain facts, repetition doesn't add truth. 10,000 nodes reading the same API ≠ more real.

Path 3

Trust the process

Public rules + immutable evidence + permissionless challenge. Not "is this entity honest?" but "was this procedure followed?" Auditable. Replayable. No subjects to corrupt.

// What you trust:
  ✓ A public SOP (anyone reads the rules)
  ✓ Immutable evidence (IPFS + hash, can't modify after commit)
  ✓ Replayable verification (same inputs → same output)
  ✓ Permissionless challenge (anyone can prove fraud)

// What you don't need to trust:
  × Any institution or node operator
  × Any AI model or its "intelligence"
  × Any verifier's reputation or stake

Oracle as peer, not servant

LayerZero gives the Oracle the same topological position as a chain. Not embedded in a chain. Communicating with chains as an equal.

Before (Chainlink model)

Oracle lives INSIDE each chain
├─ Ethereum: Chainlink nodes → feed
├─ BSC: Chainlink nodes → feed
└─ Polygon: Chainlink nodes → feed

Same fact verified N times.
N chains = N independent oracle systems.
Cognitive labor fragmented.

After (NEO Oracle + LayerZero)

Oracle exists ONCE, speaks to all chains
           ┌─→ Ethereum
Oracle ──LZ──┼─→ BSC
           └─→ Arbitrum

One judgment. Multi-chain execution.
LayerZero = nervous system.
Brain doesn't duplicate per limb.

Live on testnet

Not theoretical. Running on real LayerZero V2 infrastructure. Cross-chain AI governance dispatch verified on-chain.

Sepolia (Source)

0xaa24CC...3f45d

BSC Testnet (Target)

0xc7FFF0...8214

Cross-chain Dispatch TX

Verified on LayerZeroScan

Evidence Oracle

Four-layer prototype — local verified

Demo: Rainfall trigger (Surat Thani, Thailand)

// AI Agent — follows SOP, builds replayable evidence
Step 1: Query 2 weather sources (open-meteo, weatherapi)
Step 2: Extract 24h rainfall: source_1=6.9mm, source_2=7.09mm
Step 3: Deviation check: |7.09-6.9|/7.0 = 2.72% < 30% ✓
Step 4: Average 7.0mm ≤ 100mm threshold → NO_TRIGGER

// Evidence committed:
hash: 0xef84c192...  →  on-chain (immutable)
pack: QmEf84c19...   →  IPFS (permanent)

// Verifier — audits evidence against SOP
✓ SOP version matches
✓ ≥2 sources queried
✓ All sources in allowed list
✓ Query time within 30min window
✓ Average correctly computed
✓ Deviation correctly computed
✓ Conclusion follows from rules
→ APPROVED (9/9 checks passed)

// Challenger — anyone replays same process
✓ All checks passed. Verifier was HONEST.
   No domain expertise needed. Just rule-following.

Roadmap

✓

Phase 1

LayerZero V2 OApp integration. Oracle as chain-peer. Cross-chain AI governance dispatch. Complete.

✓

Phase 2

Four-layer Evidence Oracle. DVN-isomorphic trust model. Permissionless challenge. Complete.

→

Phase 3

Domain SOP library. Professional SOP authoring. Real-world data sources. Testnet deployment of EvidenceOracle.

Phase 4

Verifier marketplace. Stake + slash economics. Optimistic window. Multi-domain SOP governance.