Cryptographic proof for
ML model inference

Banks and fintechs run ML models for credit decisions, fraud detection, and AML screening. When regulators ask "prove the model actually ran" — today the answer is log files. Logs can be edited. Cryptographic proofs cannot.

MOOUSER generates zero-knowledge proofs that a specific model produced a specific output on specific inputs. Verifiable by anyone. Off-chain via REST API. No trust required.


The verification gap

Existing approaches to ML inference verification fall into two extremes. MOOUSER occupies the practical middle ground: mathematically complete proofs for the models regulated industries actually use.

Insufficient
Audit Logs
Timestamp + model version + output hash. Easy to fabricate. No cryptographic binding between model, input, and output.
Forgeable
MOOUSER
Zero-Knowledge Proofs
GKR+Hyrax protocol. Mathematically impossible to produce a valid proof for a computation that didn't happen. 629ms verification.
100% sound
Impractical
Full ZK for LLMs
General-purpose ZK for billion-parameter models. Would take hours-days per inference. Not viable for production workloads.
Too slow

Protocol

MOOUSER converts ML inference into an arithmetic circuit, then generates a zero-knowledge proof that the circuit was evaluated correctly. The verifier checks the proof without re-executing the model.

ML Model
XGBoost, LightGBM,
RF, LR, MLP
→
GKR Circuit
Arithmetic circuit
of the computation
→
Hyrax Proof
Polynomial commitment
+ sumcheck
→
Verify
629ms off-chain
or on-chain
1

Circuit Compilation

The ML model (tree ensemble, linear model, or neural network) is compiled into a layered arithmetic circuit. Each decision node, matrix multiply, or comparison becomes a gate. An 88-tree XGBoost model produces an 88-layer DAG circuit.

2

Proof Generation

The GKR interactive proof protocol is applied layer-by-layer, reducing the claim about the output to claims about the input. Hyrax polynomial commitments bind the prover to specific intermediate values. The proof is non-interactive via Fiat-Shamir (Poseidon sponge).

3

Verification

The verifier replays the transcript, checks sumcheck rounds, and verifies polynomial evaluation proofs. No access to model weights or input data required. Verification is O(n log n) in circuit depth — independent of the number of gates.

4

Receipt

A signed ECDSA receipt binds the proof to a timestamp and verifier identity. Receipts are recorded in a Merkle-tree transparency log — like Certificate Transparency, but for AI decisions. Tamper-evident and publicly auditable.


Guarantees

The proof binds four things together cryptographically. Tampering with any one of them invalidates the proof.

PropertyGuaranteeMechanism
Model identityCircuit hash commits to exact model weightsPoseidon hash of circuit description
Input bindingProof is bound to specific input featuresHyrax polynomial commitment
Output correctnessOutput is the unique correct result of the computationGKR sumcheck protocol
Non-transferabilityProof cannot be reused for different inputsFiat-Shamir transcript binding

What this means in practice

A bank runs a credit scoring model on a loan application. MOOUSER produces a proof that this specific model produced this specific score on this specific application. A regulator can verify this in 629ms without seeing the model weights or the applicant's data. The proof is mathematically unforgeable — it is impossible to produce a valid proof for a computation that did not happen.


Performance

Measured on an 88-layer XGBoost credit scoring model (production-representative complexity).

629ms
Verify time
130KB
Proof size
5
Model types
3,335
Tests
Model TypeSupportedProve TimeVerify Time
XGBoostYes~30s (88 layers)629ms
LightGBMYes~25s~500ms
Random ForestYes~20s~400ms
Logistic RegressionYes<5s<200ms
MLP (Neural Network)Yes~10s~300ms

Production Architecture

MOOUSER uses a TEE happy path with ZK dispute fallback. Normal inference runs in a Trusted Execution Environment (fast, cheap). Zero-knowledge proofs are only generated when someone challenges a result.

PathCostLatencyWhen
TEE (happy path)$0.0001Milliseconds99% of inferences
ZK proof (dispute)$0.02SecondsWhen challenged
On-chain (settlement)3-6M gasBlock timeCross-institutional disputes

This makes cryptographic accountability economically viable. You don't pay for proofs nobody checks.


Try it

Verify a real 88-layer XGBoost credit scoring proof.

# Verify a proof via REST API
$ curl -X POST /verify \
    -H "Content-Type: application/json" \
    -d @proof.json

{
  "verified": true,
  "circuit_hash": "0x8e7c338859ba0bcb...56e909"
}

# 629ms. 88 compute layers. Cryptographic certainty.
# Or use the Python SDK
from worldzk import WorldZK

client = WorldZK("https://your-verifier.example.com")
result = client.verify(proof_bundle)
print(result.verified)       # True
print(result.circuit_hash)   # 0x8e7c33...

Use Cases

MOOUSER is built for regulated industries where AI decisions have legal and financial consequences.

Credit Scoring

Prove to regulators (CFPB, OCC) that the approved model produced each credit decision. ECOA/FCRA compliance without exposing proprietary model weights.

Fraud Detection

Demonstrate to counterparties that transaction risk scores were computed by the declared model, not overridden manually. Cryptographic chain of custody.

AML Screening

Provide cryptographic evidence that AML models ran on the correct data. Satisfy cross-border regulatory requirements without sharing raw customer data.

Insurance Claims

Verify that automated claims decisions followed the registered model. Reduce dispute resolution from weeks to seconds with unforgeable proof.


Regulatory Landscape

The demand for verifiable AI is being driven by regulation, not speculation.

RegulationRequirementHow MOOUSER Helps
EU AI Act (2026)Auditability and transparency for high-risk AICryptographic proof of model execution + transparency log
ECOA / FCRA (US)Fair lending documentationProof that the declared model made each decision
SR 11-7 (OCC)Model risk managementImmutable audit trail with signed receipts
GDPR Art. 22Right to explanation of automated decisionsVerifiable proof without exposing personal data

Get Started

Python
pip install zkml-verifier
TypeScript
npm i @worldzk/sdk
Rust
cargo add zkml-verifier
Go
go get worldzk/sdk
# Run the full stack locally
$ docker compose -f docker-compose.offchain.yml up -d

# Or use the CLI
$ worldzk upload-model credit_model.json
$ worldzk prove --model credit-v1 --features "52000,0.38,710,4"
$ worldzk verify <proof_id>
$ worldzk receipt <proof_id>

Repository

ComponentLanguageDescription
zkml-verifierRustCore verification library — GKR+Hyrax protocol
Verifier serviceRustREST API for proof verification
Proof generatorRustProof generation service with real prover integration
GatewayRustAPI gateway with auth, rate limiting, metering
On-chain verifiersSolidityGKR, Hyrax, Groth16 verifier contracts
Stylus verifierRust/WASM24KB WASM verifier for Arbitrum Stylus
Circuit compilerRustXGBoost, LightGBM, RF, LR, MLP → GKR circuits
SDKsPy/TS/GoClient libraries for all major languages

Apache-2.0. Cryptographic infrastructure that institutions depend on needs to be auditable. The code is open. The proofs are verifiable. That's the point.