proof, not promises: the public receipt log
When you send a prompt to a cloud provider, what you get back is text and an invoice. Whether the model you paid for actually ran, on the hardware claimed, for the tokens billed — that lives in their database, readable by them alone. The entire industry runs on "trust our dashboard".
We're a marketplace of community GPUs. "Trust us" was never going to be enough — so we built the record to be checkable by people who don't.
layer one: every job carries a signature that isn't ours
Each machine in the pool holds an ed25519 key that never leaves it. Every completed job — and every benchmark — is signed by that key: model, token counts, timing, and the exact quantization that ran, identified by the SHA-256 of the weights file itself. A receipt is a claim the host makes, not one we make on its behalf. We verify it, we bill by it, and we could not forge it.
layer two: an hourly, chained, public log
A signature proves who wrote a receipt. It doesn't prove the receipt is in the record we publish, or that the record wasn't edited after the fact. So every hour, the receipts settled in that hour are sealed into a Merkle tree, and we publish a signed head: epoch number, leaf count, root hash — and the previous hour's root.
That last field is the trick. Each head chains to the one before it, so rewriting any past hour changes its root, which breaks the next head, and the next — all of which have already been fetched by people who aren't us. Silent revision stops being an option; the only way to change history is a loud, permanent, public break. Quiet hours get sealed too, because a gap in a log is indistinguishable from a deletion.
# the whole log — one line per hour, append-only, fetch and keep it
curl https://app.elephantpool.ai/api/gateway/v1/log/heads.jsonl
# the inclusion proof for one job
curl https://app.elephantpool.ai/api/gateway/v1/log/proof/<job_id>The proof is a handful of hashes. You rebuild your own leaf from data you already hold, walk the proof upward, and compare the result to a root you fetched at the time. Nothing we operate is trusted anywhere along that path — which is why all of it is public and unauthenticated. A record only its author can read proves nothing.
If the construction sounds familiar, it should: it's RFC 6962, the same design Certificate Transparency uses to keep the web's certificate authorities honest. We didn't invent the math; we just applied it to inference billing.
layer three: sampling nobody can game — including us
A marketplace has to check that work was actually done. The obvious design fails in both directions: if hosts know which jobs are checked, they behave only on those; if we choose what to check after seeing results, our "verification" proves nothing — we could look away from a favourite, or stare at someone until something seems wrong.
So the sampling is commit-reveal. Before each day, we publish the hash of a secret. During the day, a job is double-checked exactly when an HMAC of that secret and the job id falls under the sampling rate. The day after, the secret itself is published at /v1/log/beacons — and anyone can re-run the selection and confirm the checked jobs are precisely the ones the rule picks. Hosts can't predict; we can't cherry-pick. The commitment was public before the jobs existed.
And when two answers to the same prompt are compared, they're judged the way GPUs actually behave: two honest machines running the same model diverge, because floating-point arithmetic doesn't add in the same order on different silicon. Only an answer with essentially nothing in common with its replica raises the flag. We'd rather let a borderline case through and sample again tomorrow than accuse an honest host once.
what we deliberately don't claim
Precision beats adjectives, so here is the exact boundary: today's log proves we haven't quietly rewritten history. It does not yet stop us rewriting it openly and republishing from scratch — closing that requires anchoring each day's root in a timestamp nobody controls, and that's the next step on the roadmap, not a thing we'll pretend already exists. You'll notice we don't say "blockchain-verified" anywhere. When the anchor ships, we'll describe it just as precisely.
why this matters to you
If you build on the API: your compliance story stops depending on our word. Every job you've run has a receipt, and every receipt has a proof against a public root — fetchable, verifiable, storable in your own audit trail.
If your GPU is in the pool: your earnings are the sum of receipts your machine signed, provable against a log we cannot silently edit. The meter isn't ours. That's the point.