Install
Clone BTX and build from source with CMake — the same deterministic build everyone else audits. The agent verifies the binaries and version before it trusts them; there is no installer to phone home, only source it can read.
We have written about BTX as a chain: a live, post-quantum settlement layer whose proof-of-work is a matrix multiplication rather than a hash puzzle. This piece is about who runs it. Increasingly, the most natural operator of a BTX miner is not a person at a terminal — it is an AI agent on the same GPU that does its thinking.
That single substitution — agent for human operator — closes a loop. The hardware that serves a model can, in the cycles it would otherwise waste, mine the chain. The agent can install, run, and manage the miner end to end. And it can bank what it earns in keys built to outlast the quantum threat. Compute starts paying for its own autonomy.
Whyte Consolidated Research · 2026-05-25· 8 min read
Traditional mining is an operations job: someone provisions hardware, builds the software, watches the dashboards, and routes the payout. BTX is designed so that every one of those steps is expressed as source you build and RPC calls you make — there is no proprietary console in the middle. That matters because anything reducible to source and a deterministic API is something an agent can drive without supervision.
In When software spends, we argued that the agentic economy needs settlement that assumes a machine, not an administrator, on both sides of a transaction. Mining is the same argument turned around: if an agent can be a spender at machine speed, it can just as well be a producer of the asset — running the miner that secures the very chain it settles on. BTX is the cleanest place to see that, because its work is the same linear algebra the agent's own model runs on.
The verification target, in BTX's own framing, is the chain itself — not a roadmap or a marketing claim. That is precisely the kind of target an agent is good at: a thing it can check rather than be told.
BTX's consensus is MatMul Proof-of-Work: each mining attempt is a 512×512 matrix multiplication over the Mersenne-prime field 2³¹ − 1, a roughly 2 MiB working set that maps directly onto the tensor cores and matrix-multiply units a GPU already has. This is not a hash function bolted onto a graphics card. It is the identical operation — dense matmul over a finite field — that sits at the heart of training and inference. The project lists AI-training-class hardware (NVIDIA A100/H100, Apple M-series via Metal) as the recommended profile precisely because the workloads are the same shape.
Here is the part that makes an agent the natural operator. An agent serving a model does not saturate its GPU every millisecond — inference is bursty, with troughs between requests, idle fragments, pipeline stalls, and micro-batches that never quite fill the hardware. That headroom is paid-for silicon doing nothing. Because the proof-of-work is the same matrix-multiply primitive the model itself runs, an agent can co-schedule mining into exactly those gaps, turning once-wasted capacity into block-eligible work. The honest claim is not that one GPU does two full jobs at once; it is that the security computation becomes close to a side-effect of the AI workload — yield extracted from the utilization a model leaves on the table, at the kernel level where the matmuls already happen.
The economics are favourable because the overhead is small and the verification is cheap. The construction derives from the published cuPOW work and adds only about 16.5% above a bare matrix multiply at production parameters; the rest is arithmetic the GPU is built to do. Validators confirm a claimed product with Freivalds' algorithm — probabilistic checking with a false-positive probability below 2⁻⁶² — so the network never has to redo the work in full. Cheap to verify, expensive to fake: exactly the asymmetry an automated operator wants.
The choice of matrix multiplication over hashing is not cosmetic. It does three things at once. First, it makes the security budget dual-use: the hardware that secures the chain is general AI compute, so the spend is never stranded in single-purpose ASICs that can do nothing else. We made this case in Proof of Useful Work and the 2-for-1 GPU; BTX is that idea in production.
Second, it widens the miner base to anyone with AI-grade compute. As mining campuses are increasingly underwritten on megawatts, cooling, and dense-compute readiness — the same fleet economics that win AI-hosting contracts — a proof-of-work that runs on that exact hardware fits the way operators already evaluate a site. A wider, general-purpose miner base is harder to corner than one gated behind a bespoke chip.
Third, and most quietly, the chain publishes what it costs. Because BTX's ASERT difficulty is anchored to real matrix-multiply work, its difficulty process is a tamper-evident benchmark of GPU-class compute cost that anyone can read without an account or a token — the Difficulty Commons. For an agent deciding moment to moment whether a spare cycle is worth more spent mining or held for inference, a permissionless, work-anchored price of compute is exactly the signal it needs. The substrate is not just where the work happens; it is what makes the work legible.
Everything an operator does on BTX is source you build or an RPC you call. Laid out as a loop, it is a task an agent can own end to end — no human approval in the middle, every step independently checkable.
Clone BTX and build from source with CMake — the same deterministic build everyone else audits. The agent verifies the binaries and version before it trusts them; there is no installer to phone home, only source it can read.
Start btxd against mainnet and sync. Every block header the agent validates proves it accepts no one's word for the rules. Verification, not a vendor dashboard, is the source of truth.
Pull a candidate with getblocktemplate, solve the 512×512 MatMul puzzle, submit with submitblock — or use generatetoaddress for the solo path. On Apple Silicon the native Metal backend does the matrix math; CUDA is scaffolded for NVIDIA fleets.
Inference load is spiky; the troughs are wasted silicon. The miner backfills those idle cycles, tuned with batch-size knobs, so the same GPU earns instead of idling. Security spend becomes recovered utilization.
getmininginfo, getnetworkhashps, and getdifficultyhealth expose cadence, reorg protection, and Freivalds transcript guards as machine-readable fields. An agent reads them on a loop the way an SRE reads a control plane.
Rewards land in a post-quantum descriptor address (btx1z…) signed with ML-DSA-44 and recoverable with SLH-DSA. The spend policy is committed when the output is created — the agent's treasury is bounded and quantum-durable from the first coin.
A few honest caveats belong here. The native CUDA backend is scaffolded and off by default, so NVIDIA fleets mine today through the external getblocktemplate loop while Apple Silicon has a first-class Metal path. Stratum pool mining is still under development; solo mining via generatetoaddress or a miner-daemon loop is the production path. None of that changes the shape of the work — it just tells the agent which surface to drive.
An autonomous agent that earns and holds value needs a key that will still be safe long after it was generated. Classical signatures do not clear that bar: a sufficiently capable quantum computer breaks them, and a long-lived agent treasury is exactly the kind of balance that sits around long enough to be at risk. BTX removes the problem at the root. Routine spends use ML-DSA-44 (FIPS 204); recovery paths use the more conservative hash-based SLH-DSA-128s (FIPS 205). Both are NIST's standardised post-quantum schemes, and both are present from genesis — there is no migration window the agent has to survive.
The same cryptography that protects the payout also gives the agent a durable machine identity. BTX's builder path exposes service challenges: a gateway can require a fresh, chain-bound MatMul computation before admitting an expensive request — machine-native admission control that is cheap to verify and costly to automate at scale, with the caller's post-quantum wallet as its signed identity. That symmetry is striking. An agent on BTX both produces work, by mining, and can be asked to prove work, to earn access — using one key system for both.
Privacy comes in the same package. SMILE v2 confidential transactions conceal sender, receiver, and amount inside a shielded pool, with selective disclosure for the counterparties that need to see. An agent transacting on behalf of a principal does not have to broadcast its strategy to settle — accountability without a public ledger of every move.
Put the loop together and something new appears. An agent provisions a GPU to serve a model. In the idle cycles it mines BTX, banking the reward in its own post-quantum wallet under a spend policy committed at output creation. It monitors its own cadence and difficulty health, and it pays for the next interval of compute — or for a downstream service that quotes a work challenge — out of what it mined. The unit of infrastructure becomes partly self-financing, with bounded authority encoded in the chain rather than granted by an administrator.
At scale that closes into a loop worth naming. Demand for settlement raises the value of the mining reward; a higher reward draws more AI-grade compute onto the network; more compute hardens the chain's security and the credibility of its monetary rule; and because the work is real linear algebra, the cycles spent securing the chain stay productive instead of being burned. Each turn makes the next one cheaper to justify — the same flywheel that has always linked a proof-of-work asset to the cost of the work, except here the work is the operation the AI economy is already paying for.
We are not claiming a perpetual-motion machine. Mining revenue is a function of difficulty, reward, and the value of the alternative use of those cycles; the Difficulty Commons exists so an agent can do that arithmetic continuously and honestly. The point is structural: for the first time the security budget of a chain, the running cost of an agent, and the asset the agent earns are denominated in the same thing — GPU time on power-secured compute.
The field is M31 because reduction in 2³¹ − 1 is a single operation on the int32 pipelines GPUs already run; the difficulty algorithm is stateless and integer-only for deterministic consensus across platforms. Supply is fixed at 21,000,000 and issued only through work. An agent does not have to trust any of these numbers from a page like this one — it reads them from the chain with getmininginfo and verifies every header it accepts.
We do not write about BTX as a token to hold. We write about it because of what it confirms about demand for compute. Mining BTX is, underneath, a continuous bid for GPU-class hardware in power-secured facilities — the identical asset hyperscalers compete for to train and serve models. What this piece adds is the operator: when the miner is an AI agent on shared hardware, that bid is no longer waiting on a human to place it. It is automated, price-sensitive, and running in every trough of every inference workload.
It also points at a cleaner way to think about value. When the proof-of-work is real matrix multiplication, the asset is effectively indexed to the worldwide cost of useful compute: its security budget rises and falls with the price of the exact GPU hours the AI economy bids for, and BTX's Difficulty Commons publishes that index in the open for anyone to read. For a firm whose thesis is the scarcity and pricing of power-secured compute, a monetary network whose value tracks the cost of compute is not a curiosity — it is the cleanest expression of the trade we already believe in.
That is the through-line across this blog. Stablecoins financing Treasuries, AI training and inference, proof of useful work, machine-speed settlement for autonomous agents, and now agents that run their own miners — all of them resolve to one constraint: regulated, power-secured, U.S.-located compute. Agentic mining does not change the thesis. It adds a tenant that is fast-growing, price-insensitive at the margin, and increasingly able to provision itself.
Whether BTX specifically becomes the standard chain for this is not the bet. The bet is the shape of the demand it reveals — and the floor that demand puts under the only asset that can satisfy it.
BTX made the block reward a matrix multiply. The next step is small and consequential: let the thing already doing matrix multiplies — an AI agent on a GPU — install, run, and manage the miner itself, mine the idle cycles, and hold the reward in post-quantum keys. The security of the chain, the running cost of the agent, and the asset it earns collapse into one currency: productive compute.
Every credible design for the next financial layer keeps arriving at the same physical bottleneck. Agentic mining on a matrix-multiply chain is one more system, now buildable, that pays for its own security in GPU cycles — and one more reason the scarce asset to own is the compute itself.
BTX is described from its own published materials and live network. The items below are primary sources and independent background on the trends this piece sits within — they are not endorsements of any system or token.
For informational purposes only. Not financial, investment, or legal advice. Systems, protocols, and tokens referenced are described for context and are not endorsements. Technical details reflect the project's own published materials as of 2026-05-25 and may change. Mining outcomes depend on hardware, difficulty, and market conditions, and are not guaranteed. Readers should conduct their own research and consult qualified professionals before deploying capital.