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.
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.
RF, LR, MLP
of the computation
+ sumcheck
or on-chain
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.
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).
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.
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.
| Property | Guarantee | Mechanism |
|---|---|---|
| Model identity | Circuit hash commits to exact model weights | Poseidon hash of circuit description |
| Input binding | Proof is bound to specific input features | Hyrax polynomial commitment |
| Output correctness | Output is the unique correct result of the computation | GKR sumcheck protocol |
| Non-transferability | Proof cannot be reused for different inputs | Fiat-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).
| Model Type | Supported | Prove Time | Verify Time |
|---|---|---|---|
| XGBoost | Yes | ~30s (88 layers) | 629ms |
| LightGBM | Yes | ~25s | ~500ms |
| Random Forest | Yes | ~20s | ~400ms |
| Logistic Regression | Yes | <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.
| Path | Cost | Latency | When |
|---|---|---|---|
| TEE (happy path) | $0.0001 | Milliseconds | 99% of inferences |
| ZK proof (dispute) | $0.02 | Seconds | When challenged |
| On-chain (settlement) | 3-6M gas | Block time | Cross-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.
| Regulation | Requirement | How MOOUSER Helps |
|---|---|---|
| EU AI Act (2026) | Auditability and transparency for high-risk AI | Cryptographic proof of model execution + transparency log |
| ECOA / FCRA (US) | Fair lending documentation | Proof that the declared model made each decision |
| SR 11-7 (OCC) | Model risk management | Immutable audit trail with signed receipts |
| GDPR Art. 22 | Right to explanation of automated decisions | Verifiable proof without exposing personal data |
Get Started
pip install zkml-verifier
npm i @worldzk/sdk
cargo add zkml-verifier
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
| Component | Language | Description |
|---|---|---|
| zkml-verifier | Rust | Core verification library — GKR+Hyrax protocol |
| Verifier service | Rust | REST API for proof verification |
| Proof generator | Rust | Proof generation service with real prover integration |
| Gateway | Rust | API gateway with auth, rate limiting, metering |
| On-chain verifiers | Solidity | GKR, Hyrax, Groth16 verifier contracts |
| Stylus verifier | Rust/WASM | 24KB WASM verifier for Arbitrum Stylus |
| Circuit compiler | Rust | XGBoost, LightGBM, RF, LR, MLP → GKR circuits |
| SDKs | Py/TS/Go | Client 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.