Cloudana is a decentralized compute network in which the work that secures a provider's reward is the computation a user paid for. No wasted puzzle. No "just trust the provider." One matrix multiplication does both jobs — and this page performs it, live, below.
The hardness of Cloudana's proof comes from the full transcript of intermediate computation blocks — not from the answer.1 You can shortcut the answer with low-rank tricks; you cannot shortcut the transcript. So the proof is only valid if the provider genuinely did the work.
And that work is the user's matrix multiply — so the same operation yields both a proof you can't fake and a result somebody actually wanted. That single property separates useful work from every hash lottery that preceded it.
1. After Komargodski & Weinstein, Proofs of Useful Work from Arbitrary Matrix Multiplication (2025). Our construction is cuPOW; the module is public in the repository. ↩
Derive low-rank noise E, F from the block-hash seed σ. Form A+E and B+F so the work cannot be precomputed.
Compute the product in r×r blocks, hashing every intermediate block into a transcript. This is the part that cannot be shortcut.
z = hash(σ, transcript, H(A), H(B)). A certificate is valid when z meets the network's difficulty target.
Recover C = A·B cheaply. C returns to the user as the answer. Reward is paid only for work backed by a real workload.
Good papers invite replication; this one ships the apparatus. Press run: your browser multiplies two real 64×64 matrices in 8×8 blocks, chains every block through SHA-256, seeds σ from the latest Base Sepolia block, and grinds a nonce to the difficulty you choose. Then it re-verifies its own certificate independently — the same redundancy check our testnet orchestrator performs.
Today, a trusted orchestrator verifies each certificate by re-running it — a normal way to launch, but not "completely decentralized," and we won't call it that. Full trustlessness arrives when a zkSNARK verifies proofs on-chain and the orchestrator leaves the critical path.
We'll claim decentralized verification when it's true, not before. In this field, saying exactly where you stand is the rarest feature — so it's ours.
A consensus mechanism where the computation that proves a provider did work is the same computation a user paid for. cuPOW derives proof hardness from the full transcript of a matrix multiplication — so the proof is only valid if the provider genuinely computed the user's result.
On testnet, an open-source orchestrator re-verifies each certificate. On mainnet, a Groth16 zkSNARK verifies proofs on-chain in O(1), removing the orchestrator from the critical path.
Every CLD reward is backed by a paid workload — users pay real value for real compute, and 2% of every payment is burned. Emission is tied to work performed and scarcity to usage, not to a liquidity pool or speculation.
Not yet, and we say so. Testnet is trust-minimized and orchestrator-coordinated. Full decentralization arrives when zkSNARK verification is live on-chain — that's the mainnet milestone, and we won't claim it before it's true.
Install the node once. It auto-detects your CPU, GPU, RAM and disk, classifies its tier, and self-registers on-chain. No spec forms, no bidding marketplace.
No — by design. A useful-work network must always pay its providers, so emission decays to a permanent 1.5% tail instead of halting. The 2% burn on payments means high usage turns supply deflationary: a soft cap set by the market, not a hardcoded number.
Install once. The node detects your CPU, GPU, and memory, classifies itself, and registers. No spec forms. No bidding. Just useful work.