Open-Sourcing Inference Mining
Five Days, One Coin, and a Rant

Chapter I: A perfectly ordinary coin integration

When we add a new coin to Suprnova, there’s a rhythm to it. We’ve done this dance since 2013. Read the daemon docs, spin up a node, sync the chain, plug it into the pool backend, point a couple of test rigs at it, watch the shares roll in, verify a block, high-five nobody in particular, and move on. Two days, give or take a coffee.

TensorCash looked, at first glance, like an easy one. The chain is bitcoind under the bonnet — a Bitcoin Core fork with a rebranded qt icon (the tell was that the smaller pixmaps were still the default Bitcoin “B”, but that’s a story for another day). RPC, wallets, block templates, all the ordinary furniture in the ordinary places. Grand. This will be a doddle.

Then we tried to actually mine.

Chapter II: In which the mining side of the house turns out to be a haunted mansion

Here’s the thing about a “proof-of-inference” coin. Instead of hashing SHA256 like a normal, well-adjusted piece of PoW software, the miner runs a large language model — think Qwen3-8B, that sort of thing — and the “proof” is a small verified fragment of the model’s output. That’s a legitimately clever idea. It’s the pitch of TensorCash: your electricity does something more socially defensible than heating a garage while producing a number.

We were excited. We were, quite honestly, hoping to give something back to the community by hosting this properly.

Then we opened the officially blessed miner. And it was … a binary. Just a binary. Which does what?

We stared at it. It stared back. The strings output was unhelpful in the way that only a stripped release build can be. There was, we swear on the mempool, zero documentation of what it actually spoke on that WebSocket. Not a whitepaper. Not a README with a “here’s the message flow” section. Not even a lonely protocol.md gathering dust in a repo somewhere.

We looked at the pool side. Same story. The official pool software: closed. The stratum-ish thing it exposes on the miner side: undocumented. If you want to run a pool, apparently the intended path is “email us and hope we like you.”

Chapter III: Two days of reverse-engineering the wheel

We had a choice. Option A: sigh, wire up the closed miner, hope the inference server stays up, and cross our fingers that nobody at the other end feels like flipping a switch. Option B: figure out how the thing actually works, write our own, and document it so the next person doesn’t have to.

Reader, we picked B. Naturally we picked B. This is Suprnova; we’ve been running pools since 2013, and the phrase “just trust the binary” makes us break out in a mild rash.

The first two days went roughly like this:

• Day 1, morning: tcpdump the wire, read the WebSocket frames, decode the JSON, discover that most fields are single-letter abbreviations that seem to have been chosen at random. Coffee.
• Day 1, afternoon: map out the request/response pairs. There’s a job, there’s a share, there’s a periodic keepalive, and there’s a fourth message type that we called “the one that stops the miner if you don’t reply within 30 seconds.” Charming.
• Day 2, morning: figure out how the proof is packed — token IDs, verifier hashes, model version pinning — and correlate it back to the daemon’s submitblock path. This is the bit where TensorCash’s bitcoind ancestry actually helps.
• Day 2, afternoon: more coffee. Realise that the “inference server” in the middle is largely a share-validation service that could just as easily live inside the pool. Which is exactly where it belongs. Silently vow to write this down.

At the end of day two, we had an on-paper specification of the protocol the closed miner speaks. Not a spec anyone at TensorCash publicly ratifies — but a working, testable description of what actually happens on the wire, verified against real, valid shares. That’s what a public spec is for: it lets other people check your work, which is a load-bearing property of any protocol worth its salt.

Chapter IV: Building supr-meow-tsc, the honest version

With a real spec in hand, the rest was — we regret to inform the drama-hungry reader — actually rather pleasant.

We built supr-meow-tsc, our open-source TensorCash miner. It speaks a proper stratum dialect that we designed to be familiar to anyone who’s ever configured cpuminer or a Bitcoin ASIC. The core protocol looks like this, and yes, that’s the whole handshake — not a hand-wave:

// Miner subscribes
--> {"id":1,"method":"mining.subscribe","params":["supr-meow-tsc/1.0.0"]}
<-- {"id":1,"result":[["mining.notify","abc123"],"00",4],"error":null}

// Miner authorises (worker.name / password)
--> {"id":2,"method":"mining.authorize","params":["grsX...worker1","x"]}
<-- {"id":2,"result":true,"error":null}

// Pool sends a job (job_id, prevhash, model_id, prompt_seed, target, clean)
<-- {"id":null,"method":"mining.notify","params":[
      "j-8f01","000000...abcd","tsc-qwen3-8b-bf16",
      "b5c4...","1fffff",true]}

// Miner submits a proof (job_id, extranonce2, token_ids, verify_hash)
--> {"id":3,"method":"mining.submit","params":[
      "grsX...worker1","j-8f01","0001","[128,42,997,...]","9c93..."]}
<-- {"id":3,"result":true,"error":null}

That’s it. That’s the whole flow. It’s six method calls, it fits on one screen, and every field has a name that isn’t a random letter of the alphabet. You can wireshark it, you can implement it in a weekend, and if you don’t like our implementation you can write your own tomorrow.

We ship the miner as source. The Rust builds are reproducible. There are no hard-coded remote servers. The only outbound connection supr-meow-tsc makes is the stratum TCP you configured. If you point it at localhost, it talks to localhost. If you unplug your internet, it stops talking — because that’s what network sockets do, not because a mystery service has revoked your licence.

Chapter V: Why bother? A brief business case

“Fine,” you say, tapping the desk, “but why does Suprnova care? Just ship the closed miner, take the fees, move on with your life.”

Three reasons.

Security audits. The kind of miner we actually want on our infrastructure is the kind we can read. Nobody sensible installs a random closed-source Rust binary on a production rig anymore — not after the last few years’ worth of trojanised miner campaigns. (We’ve written about one of those in our advisory on the SRBMiner / NovaHash rootkit dropper. Highly recommended reading if you’re still convinced “it’s only a miner” is a safe frame of mind.)

Interop. If our stratum spec is public, another pool can implement it in an afternoon. Another miner author can build a competing implementation. A HiveOS packager can add TSC to their flightsheet menu without emailing anyone. That’s a healthier ecosystem than one where a single closed pipeline holds the whole coin together with the mining equivalent of chewing gum.

Community goodwill. TensorCash rides the current wave of AI-hyped coins — proof-of-inference is a genuinely interesting idea, and we’re glad to be running a pool for it. But an idea that ships as a closed binary is an idea one abandoned domain away from a dead network. We’d rather spend the extra three days now than watch a good coin die of neglected middleware.

Chapter VI: The five-day accounting

For the pool-operator readers in the audience, here’s the actual budget:

That last stat is the important one. The next TSC pool operator, whether it’s a competitor, a curious hobbyist, or a future version of us that’s forgotten everything, gets a two-day integration back. And so does the pool after that. And the miner author who wants to try a smarter inference kernel. Every wheel-reinvention we did over those extra three days pays out infinitely from here on.

We’ll take that trade.

Chapter VII: What we’d like to see happen

A gentle, humble list of wishes, from a pool operator to the wider inference-coin community:

1. Ship your miner as source. If you’re worried about competitive advantage, the honest answer is that your competitive advantage was never the miner. It was the chain, the model, and the community. The miner is a driver — drivers are supposed to be open.
2. Document the protocol. Even a rough, hand-drawn sequence diagram is infinitely better than nothing. If you can’t explain your protocol on a napkin, you probably don’t understand your protocol.
3. Don’t hard-code remote servers. Please. If your miner refuses to run without wss://central.example.com, you have built a subscription service, not a decentralised network.
4. Adopt public stratum, even loosely. The mining stratum protocol is one of the most successful protocols in crypto. It’s ugly, it’s ad-hoc, and it’s glorious. It also just works. Extend it, don’t reinvent it.
5. Have a chat with your local friendly pool operator. We’ve been doing this for over a decade. We’re not going to steal your model weights. We might, however, save you a few embarrassing bugs before mainnet launch.

Chapter VIII: Try it, break it, tell us

TSC is live on Suprnova today. You can point supr-meow-tsc at stratum+tcp://tsc.suprnova.cc:3310 (the main port; 3309 is the alternate), configure your TensorCash address as the worker username, and mine. The full setup guide lives on the pool’s Getting Started page, and the protocol spec is right there next to it — not hidden behind an email address, not gated by a Discord DM.

If you find a bug in the miner, open an issue. If you find a bug in the protocol spec, tell us — we’d rather patch a spec than defend a mistake. If you build a competing miner that’s faster than ours, we will politely applaud and then benchmark yours against ours in a future Labs post. That’s how a healthy mining ecosystem is supposed to work.

And if you’re a coin developer reading this and feeling a bit called out — friendly hint — you’re very welcome to steal every idea in this article. Open your miner. Publish your protocol. The community will thank you, the pools will integrate you in a weekend, and the closed-binary vendors will … well, they’ll find something else to sell.