TensorCash: useful proof-of-work for verifiable AI
The same GPU forward pass that answers a prompt produces the proof that extends the chain. Mainnet is live.
Disclosure: I work on TensorCash. This is a technical intro, not a financial promotion. There is no sale, presale, airdrop, or price talk in this thread and I will not discuss any. The point of the thread is the mechanism, so tear it apart. The one-line claimProof-of-work does not have to be wasted. On TensorCash the "work" is a real model forward pass serving an actual prompt, and the proof that the model ran is what secures the block. Same security argument as any PoW (costly to produce, cheap to verify, expensive to forge). The joules just do a job on the way.
The two security premises, stated plainly- The randomness is not the miner's. Sampling draws are derived by hash from the mining context (block hash, VDF output, tick, target): a deterministic, replayable stream, not an RNG the miner controls. You cannot re-roll a draw you don't like: the only way to explore the search space is to pay for another forward pass.
- The entropy is the model's. Which continuation those hash-bound draws select depends on the model's full logit distribution at every step, and a consensus entropy gate rejects degenerate low-entropy output. So every lottery ticket costs one real forward pass of the claimed model and the statistical replay (below) checks the recorded logits really are that model's.
That is the whole PoW shape: hash-seeded draws play the role the nonce plays in hashing, the forward pass plays the role of the hash function, and the proof is checkable after the fact.
The formal core (Theorem B.2 of the paper)Those premises are proved, not asserted. Model the sampler draw at step j as u_j = H(header, j, prefix) through a random oracle, and let consensus enforce a minimum per-path entropy floor of B_min bits. Then for
every generator f and every grinding adversary that pre-selects at most L candidate token paths, the per-trial probability of an accepted solution is at most
q · min(1, L · 2^-B_min)
where q is the ordinary difficulty-target probability. The proof uses only measure preservation of the hash-driven sampler and the entropy floor, not the shape of the model, the prompt, or the adversary's construction rule, so every cached-tree, beam, or refine strategy is an instance of it. Plain reading: pre-building L paths buys you at most L·2^-B_min per trial, i.e. grinding the sampler is exponentially worse than just running the model. Theorem, proof, and parameter table: Appendix B of
the paper.
What it actually isA layer-1, Bitcoin-derived (UTXO model, 10-minute target spacing; unit: TENSOR). Blocks are currently coming much faster than target and hashrate has been growing quicker than the 4x-clamped retargets can track, so spacing sits around 90-100s while difficulty catches up; check the explorer, the chart is public. Not a token on someone else's chain, and not "a verifier bolted onto an API." The block reward is a native, non-token incentive paid for doing inference. Miners search continuations off-chain; validators replay only the winning path in a single pass. Every served token path carries a replayable proof, so anyone can confirm which model actually ran.
The hard part: verifying inference without re-running itThis is where most "useful work" coins fall over, so here it is concretely. You cannot just re-execute and diff outputs, because inference is not deterministic across GPUs, kernels, or precision, so any tolerance loose enough for honest hardware also passes a cheaper stand-in. TensorCash uses calibrated statistical replay instead:
- The proof surface is compact and external: token IDs + sampler draws + top-50 support logits + 20 fixed tail canaries per step, plus compact summary stats. No hidden states, attention maps, or layer traces.
- The sampler draw is hash-bound, so a 4-bit miner cannot search cheaply and then submit under the full-precision identity.
- Verification is a single-path teacher-forced replay; one parallel pass over the recorded tokens, ~190x faster than generating them; not a re-run of the whole job.
Measured numbers from our paper (falsifiable: Qwen3-8B bf16 + Qwen3-32B fp8 on L40S, honest cross-hardware acceptance on A10G/L4):
- Proof-emission overhead: 8B 6.6% to 9.4% (batch 1-16), about 12% at saturation; 32B fp8 3.4 to 6.7%. Overhead falls as the model gets bigger.
- Forgery detection (live GPU replay): honest proofs 97.3% GREEN / 2.7% AMBER / 0% RED; cross-arch swap, same-arch fine-tune, and 4-bit quant all 100% detected. A cheap fingerprint screen alone misses the fine-tune and quant cases, so full replay is the decisive check.
- Quantization-search resistance: honest bf16 vs real 4-bit, same seed, n=512, gives 0/512 terminal proof-hash overlap with first divergence at step 0.
Consensus and chain- Useful PoW plus the calibrated statistical replay above.
- A VDF "cumulative tick" adds a proof-of-time component, so the chain self-heals liveness and resists deep reorgs.
- Assets are consensus-native: an issuer picks the rules (ticker, supply cap, transfer policy, KYC, governance) and the protocol enforces them at every spend, instead of each token being bespoke contract code you have to audit.
- Emission: a fixed total supply on an epoch-decay schedule, no official sale. I am keeping this factual and pointing at the schedule rather than dressing it up. See the mission/emission page and the whitepaper for the exact curve.
Mine it (mainnet is live)Mining rides the same forward passes, so you can start from scratch or monetize spare capacity.
- Apple Silicon: TensorMiner (Metal) or the llama.cpp host worker.
- NVIDIA: Docker + vLLM (build matrix by compute capability).
- No GPU: a CPU worker exists — fine for trying the stack; competitive mining is GPU territory.
- Two modes: broker (point inference at a provider, minimal setup) or standalone (run your own node). Network is selected by CHAIN_NAME = tensor for mainnet, tensor-test for testnet.
- The mining model must be chain-approved and is pinned per revision; approved models are listed on the explorer.
Full walkthrough:
tensorcash.org/blog/how-to-mine Don't trust, verify (please do)The verifier is open source. Replay any proof yourself and confirm which model produced it:
Where it sits (named honestly)We did not invent verifiable inference and will not pretend to. TEEs (Intel SGX, NVIDIA Confidential Compute) do it at roughly 5 to 10% overhead but you have to trust the chip vendor. zkML (Bittensor/Omron) is sound but far too slow to prove real-time LLM inference today. Gensyn is bitwise re-execution but a compute market, not an L1 whose block reward is the inference. Gonka is close on the "PoW 2.0" framing. TensorCash's specific bet is a full L1 where the PoW is the useful inference and verification is a replayable, model-attesting statistical check, with no enclave and no per-inference zk circuit.
Links What this is NOTNo presale, no ICO, no airdrop, no giveaway, no "buy" link, and I cannot and will not give price or where-to-trade info. The coin is mined by doing inference. If anyone DMs you an "official" sale or a multiplier offer, it is a scam. There is no official sale.
Skepticism is welcome. The whole pitch is that you can check it rather than trust me, so fire away and I will answer in the thread.
