AI plus crypto is the easiest pitch of this cycle. Every deck now ships with a “Proof of Something.” The name is marketing. The object the protocol actually rewards is the business.
So what does each proof actually prove?
TensorCash: inference as block work and market receipt
TensorCash puts real model inference in the block.
Pick a prompt. A real autoregressive model answers it exactly the way it would for a paying customer. The sampling trajectory produces the proof, and the proof mines the block. No second GPU puzzle idling beside the useful work. No capacity score standing in for it. No validator voting on whether the answer “looks intelligent.” The inference is the work.
That same proof is also the receipt that lets the inference be sold on the open market without trusting the provider. An unknown operator does not need a cloud brand to establish which model ran. The buyer can verify the receipt, then compare providers on price and latency. Datacenters can participate on exactly the same basis.
The formal evaluation measured single-digit proof-emission overhead at normal serving points. Then the production mining software tightened its logging and the measured overhead dropped to zero—the residual was a logging artefact, not inference work. This is not “useful in theory.” It is running software.
Every validating node runs the same deterministic verification code. It replays the declared model and precision and applies calibrated statistical boundaries designed for the numerical reality of GPU inference. Honest hardware variation falls inside the boundary. Substituting fp8 for a required bf16 model does not. That is not a remote opinion and it is not stake-weighted taste. It is a protocol-defined test.
And the work is exclusive. The same inference cannot mine two TensorCash blocks. It is consumed into one candidate block, just as one Bitcoin hash attempt cannot mine two candidate blocks at once. That matters because a GPU-capacity claim or a model-residency claim can be made to ten networks at once unless those networks can prove and punish double-booking.
Now compare that with what the other mechanisms actually buy. The full comparison, with citations, is in the Verifiable Inference paper; this is the plain-language cut.
Proof of Model
Projects reviewed: Keryx.
Keryx calls its mechanism Proof-of-Model. Its mining working set is made from model weights, so the proof demonstrates that a miner holds the model in GPU memory.
A loaded model is not an inference.
Keryx’s own paper admits the boundary: Proof-of-Model proves possession of the weights; correctness of a generated answer is handled by a separate optimistic challenge mechanism. Two mechanisms, because residency is not execution.
Now answer the economic question. What stops the same GPU, holding the same model, from proving residency to several reward systems? What happens when every chain pays for the same alleged capacity? If the answer is “we check periodically,” the GPU is being paid for passing checks, not for producing exclusive useful work.
TensorCash one-liner: a resident model can be claimed many times; one real TensorCash inference can mine only one block.
Proof of GPU, capacity and hardware attestation
Projects reviewed: io.net, Aethir and Phala.
io.net runs an hourly proof-of-work hardware check to authenticate a GPU, its VRAM and performance. Aethir pays Proof-of-Capacity rewards for containers being online and ready even when they are not doing customer work. Trusted-execution systems such as Phala add vendor-backed hardware and software attestation.
These systems can prove a machine exists, is available, or booted an approved stack. They do not automatically prove that the paid capacity was used exclusively. Register one GPU with several networks, pass each periodic check, and collect several availability rewards until real jobs collide. Where is the cryptographic exclusivity? Where is the penalty when the same physical capacity is sold twice?
Hardware attestation has another answer: trust NVIDIA, the firmware, the attestation service and the measured software stack. That may be acceptable for a confidential cloud. It is not decentralised proof that useful inference secured a block.
TensorCash one-liner: a GPU can pass many capacity checks; the inference inside a TensorCash block cannot be double-booked.
Proof of MatMul
Projects reviewed: BTX and Pearl.
BTX mines finite-field matrix multiplication. Pearl builds a chain around proof-carrying matrix multiplication and connects it to a modified inference server.
Nockchain is a footnote here, not a separate mechanism. Its paper points to the same arbitrary-MatMul cuPoW as a future route for AI mining. It therefore inherits the same critique below.
Matrix multiplication is part of inference. A piston firing is part of a parcel delivery. Proving the piston moved does not prove the parcel arrived.
A real model response also contains attention, KV-cache behavior, normalization, routing, sampling, model identity, prompt identity and a dependent sequence of tokens. A detached MatMul proves none of that. It proves a GPU ran a matrix puzzle that AI also happens to use.
The economic question is simpler than any benchmark number. If mining while inferring makes the machine slower at both jobs, rational operators specialise: mine, infer, or split the hardware between the two. The efficient miner removes everything the proof does not require—including the customer inference path.
Once the inference can be stripped away while the reward remains, “useful AI mining” has collapsed back into a dedicated GPU puzzle. The fact that models also use matrix multiplication does not make the mined matrix operation a saleable model response, and its proof cannot serve as the receipt for that response.
TensorCash one-liner: TensorCash mines the response the customer bought, not a detached matrix operation that can be ground more profitably without a customer.
Proof of Transformer and benchmark-based capacity
Project reviewed: Gonka.
Gonka’s Proof of Compute runs short, competitive Sprints on randomised transformers. Sprint performance sets compute weight, and compute weight determines consensus power and the share of inference work allocated afterward.
That is the gap in one sentence: the thing that proves capacity is not the thing the customer buys.
Operators are economically pushed to optimise for the Sprint because that score controls power and future allocation. Gonka has added confirmation checks, preserved inference nodes, reputation and model-specific proof groups to police what happens afterward. Those controls recognise the attack, but policing hosts after a benchmark does not turn the benchmark into customer inference. It hires a second system to enforce what the first one could not prove.
TensorCash one-liner: Gonka measures a transformer race and then enforces service; TensorCash makes the service itself the proof-of-work.
Prover–verifier networks
Project reviewed: Bittensor.
Bittensor miners produce work in subnets. Validators score it. Stake-weighted Yuma Consensus converts their weights into emissions.
Even when the work itself is off-chain, every new kind of work needs its own incentive mechanism, validators capable of judging it, and enough on-chain coordination to pay for it. That is the scaling ceiling.
The deeper problem is ground truth. A verifier is only as good as its scoring function, and “this answer is good” is not an objective consensus rule—it is a judgment with a block reward attached. Bittensor’s own documentation describes the weight-copying problem: validators can earn by predicting and copying the consensus instead of doing the evaluation.
Some subnet tasks can be scored cleanly. Many cannot. In every case, the coin distribution is only as objective as the validators and their metric.
TensorCash one-liner: Bittensor records who validators rewarded; TensorCash verifies which model produced the inference.
Proof of Logits
Project reviewed: Ambient.
Ambient’s Proof of Logits is the closest claim: miners hash logit markers and validators recompute a random token.
The same model does not emit byte-identical logits across GPU architectures, kernels, batching regimes and precision paths. Ambient’s litepaper answers that it creates “hardware agnostic representations” of logits. The security of that claim depends on the exact rule, cross-GPU calibration, and measured false-accept and false-reject rates. The normalization must be tight enough to catch a cheaper model or precision without rejecting honest hardware.
This is not a footnote. A raw hash is too brittle for honest GPU variation; a loose normalization is easy to game. The entire security claim lives between those two failures.
TensorCash already did the work. Its verifier uses calibrated statistical levels over real cross-hardware execution. The network has distinguished bf16 from fp8 on the same model in live blocks, and the lower-precision blocks received zero work. The evidence is public.
TensorCash one-liner: Ambient declares the logits hardware-agnostic; TensorCash measures hardware variation and enforces calibrated boundaries.
What is actually unique
TensorCash is not claiming that nobody else owns a GPU, runs a model, computes a matrix, benchmarks a transformer, scores AI output or hashes logits.
It claims something much more precise, and nobody has produced a counterexample:
A normal, saleable model inference is the block work itself. The same work cannot be mined twice, every node verifies it against calibrated model-specific boundaries, and the mining proof is the receipt that lets the inference be sold on the open market without trusting the provider.
That is why an unknown GPU operator can compete with a datacenter on the things that should decide a compute market: price and latency. And it is why a datacenter can adopt TensorCash on inference it already sells, rather than choosing between serving customers and running a separate mining puzzle.
If another live chain does the same, send the block, the proof, the verifier and the end-to-end throughput numbers. We are here to talk.
Until then, read the proof—not the pitch.
Authored pseudonymously by Imosuke Takakuni.