Proof of AI: An Open-Source Cloud That Pays the Developers It Runs On

Two hard problems sit underneath every "decentralized AI" pitch, and most projects wave at both.

The first: how do you trust a result you didn't compute? If a remote machine says "the model output X," how do you know it ran the model at all — not a cheaper one, not garbage, not a cached lie?

The second is quieter and, we think, more important: the entire AI stack is built on open source that almost nobody pays for. Your inference server, your tokenizer, your vector index, your crypto library — written by people who see none of the revenue their code generates.

Proof of AI (PoAI) is our answer to the first. Our payout commitment is our answer to the second. This post is an honest account of what is live today, what is wired but dormant, and what is still roadmap. We will be explicit about which is which — because the whole point is verifiability.

What Proof of AI actually proves

AI computation is famously hard to verify because floating-point math is non-deterministic: the same model, same input, same GPU can produce slightly different numbers depending on operation order and scheduling. You cannot reach consensus on a number that changes every time you compute it.

PoAI removes the non-determinism instead of trying to prove around it:

1. Integer-only inference. Weights and activations are quantized to int8. Accumulation is int32, scaling is an arithmetic right-shift, outputs saturate, and transcendental functions are frozen lookup tables — never exp() or rsqrt(). The result is a forward pass that is bit-for-bit identical on CPU, Metal, CUDA and AMD.

2. Recomputation, not trust. The integer transformer is exposed as an EVM precompile. The trust model is the simplest one that exists: every validator re-runs the identical computation during block execution. If your output does not match what everyone else's machine produces, your block is rejected. No committee, no special hardware, no proof to forge.

This is the variant of PoAI our research first described in Proof of AI: Verifiable Compute as a Consensus Primitive (ZIP-002), now shipped as code.

This part is live

The keystone is a deterministic int8 matrix-multiply — gemm_i8 — implemented byte-identically in Go, Rust, and C++, with GPU kernels (Metal, CUDA, HIP) that pass the same known-answer tests. The Go implementation is a registered EVM precompile at address 0x0300...0003, blank-imported by the Lux, Zoo and Hanzo EVMs, so the same deterministic inference path is shared across all three chains. A golden token sequence is asserted across every language as a test:

prompt  1 7 13 2  →  4 28 21 17 2 19 43 35 36 15

If that vector ever differs between two machines, CI goes red. That is what "verifiable" means in practice.

This part is honest roadmap

• Model size. The on-chain precompile runs a small reference transformer today. The port of a production model (Qwen3-0.6B / zen-nano) is specified and in progress — recomputing a frontier model in every validator is not the goal; small verifiable models and sampled verification of large ones are.
• Cryptographic proofs. zkML proofs and confidential (TEE) execution are designed and stubbed for a later release. Today's guarantee is determinism you can re-run, which is a real guarantee — just not a succinct proof.
• Hardware attestation. For models too large to recompute on-chain, the trust anchor is a hardware attestation. AMD SEV-SNP attestation is implemented end-to-end in our stack (full certificate-chain verification against AMD's key service); Intel TDX and NVIDIA GPU confidential compute are scaffolded, not finished.

We would rather tell you this than ship a slide that says "zk-verified AI."

The open-source payout: 25%, by design

Here is the commitment, and it is in our code, not just a blog post: 75% of attributable cloud revenue stays with the platform; 25% is pooled for the open-source developers whose packages the cloud actually ran.

How attribution works, end to end:

Step	What happens
Build	Every image our build system produces gets a Software Bill of Materials (syft → CycloneDX) — the exact dependency graph of what shipped.
Attribute	A git blame engine maps each dependency to its authors, line by line, producing per-author contribution percentages.
Meter	The cloud already meters usage per organization for billing. That usage is the cost basis.
Split	Usage is allocated across the dependency graph, weighted by contribution, and 25% of the attributable amount is reserved for contributors.
Pay	Contributors are paid — to start, in non-expiring Hanzo credits; crypto and fiat rails follow.

We are being precise about status: the SBOM generator, the attribution engine, the 25% split, the metering, and the payout model all exist in code today. What we are wiring now is the connective tissue — turning on SBOM ingestion, scheduling the payout run, and routing real money through the rail that already pays arbitrary recipients. The first payouts go to the dependencies Hanzo Cloud itself runs on, as the reference implementation.

Link your repo, get paid

The end state is self-serve: connect a GitHub repository, verify you own it, choose how you want to be paid, and receive a share whenever Hanzo Cloud runs software that depends on yours. That onboarding flow is the piece we are building next. When it lands, it will be the literal subject of this post's title — and you will be able to verify your own earnings against the SBOM that produced them.

Running a node, and sharing the cloud

Node operators. Hanzo Node lets a machine enroll with a cryptographic identity, advertise what it can do, receive work over a peer-to-peer network, and get paid for it via stablecoin settlement (x402). That loop is real today for agent and tool work. The fully hardware-metered, attested compute marketplace — where you sell GPU time under a TEE attestation and settle on-chain — is the direction, built on the attestation and settlement primitives above, not a shortcut around them.

Referrals and sharing. Refer a developer or an organization and you both earn credits; affiliates earn a tiered share of referred spend. This is live in the billing system today, fraud-gated and tested — the same revenue-sharing machinery that the open-source payout builds on.

Why this matters

An AI cloud that cannot prove its results is asking for blind trust. An AI cloud that profits from open source without paying it back is not sustainable. Proof of AI addresses the first with the most boring, most robust mechanism available — deterministic recomputation — and our 25% payout addresses the second with a number we wrote into the code.

The honest scorecard: the verifiable-inference core is shipped and tested; the payout pipeline is built and being switched on; the proofs, the large-model port, and the self-serve front door are roadmap with real foundations underneath them.

We will keep publishing what is real and labeling what is not. That is the only way "Proof of AI" means anything.

---

Hanzo AI is Techstars '17. The technical audit behind this post — every claim mapped to a file and line — is maintained internally and drives the build plan.