Loading...
Loading
Overview
Registration Activity
Neuron registration trends
This Interval
0
— burn · — PoW
Target / Interval
Loading
Neuron registration trends
Large language model inference is hard to audit: a provider can silently serve a smaller model, skip computation steps, or return cached outputs while billing for full compute. Centralized providers offer no mechanism to verify that the model actually ran, let alone ran correctly—leaving buyers to trust claims rather than evidence.
A decentralized network of GPU contributors, scored purely on verifiable performance, changes this dynamic. When every inference request can carry a cryptographic proof that the specified model executed the specified computation, and validators continuously test endpoints with requests indistinguishable from real traffic, cheating becomes detectable and costly. Miners who pass earn emissions; those who fail proofs or miss canary obligations enter probation and lose score.
Verathos (Subnet 96 on Bittensor) implements this architecture end-to-end. Miners register qualified model endpoints—single-GPU vLLM servers or multi-machine GGUF mesh pools—on an on-chain MinerRegistry contract. Validators discover miners, verify their identity via SR25519 challenge-response, dispatch canary requests carrying proof-v2 Merkle-tree or proof-v3 ZK obligations, and score each endpoint on throughput, latency, context length, quantization quality, and proof validity. A hot-capacity audit system uses on-chain block hashes as randomness beacons to schedule deterministic GPU workload proof windows. Results flow through a co-located gateway to an OpenAI-compatible API, with score-weighted routing directing organic traffic to the best-performing endpoints.
api.verathos.ai using any OpenAI SDK and receive cryptographically auditable inference without managing GPU infrastructure./v1/models and verify the returned proof receipt that the declared model executed their prompt.Use cases were auto-generated from the GitHub repository and may not reflect the latest changes.
Verathos (Subnet 96) is a Bittensor subnet that provides cryptographically verified LLM inference, allowing miners to serve qualified model endpoints (via vLLM or distributed GGUF mesh pools) and earn emissions based on throughput, latency, and model utility. Validators test miners with indistinguishable canary requests, verify zero-knowledge or mesh proofs of correct computation, and score miners on throughput, latency, context length, quantization quality, and proof validity, with results published as OpenAI-compatible API traffic routed through the subnet's proxy infrastructure.
The subnet consists of miners serving LLM inference endpoints and validators testing those endpoints. Miners run either vLLM (single GPU) or GGUF mesh pools (multi-machine distributed inference) and register their model endpoints on the MinerRegistry smart contract on the Bittensor EVM. Validators discover active miners via the MinerRegistry, perform identity verification (SR25519/EVM challenge-response), dispatch canary inference requests indistinguishable from organic traffic, verify cryptographic proofs (proof-v2 Merkle-tree-based or proof-v3 ZK-based), and score miners via EMA.
Validators write shared state (scores, mesh verification snapshots, routing decisions) to a local file consumed by co-located gateway/proxy processes that route OpenAI-compatible API traffic to miners. A hot-capacity audit system schedules deterministic GPU workload proof windows using on-chain block hashes as randomness beacons. The subnet uses both Substrate (Bittensor) for weight-setting and an EVM sidechain for contract-based miner/validator registration, model registry, and payment processing.
Verified AI inference and training subnet.
This information was auto-extracted from the GitHub repository and may be incomplete or out of date. Always refer to the subnet's GitHub repository for the latest instructions.
Validators dispatch canary tests (indistinguishable from organic traffic) every epoch. Each miner receives 2+ planned canary obligations per epoch (small low-context + full-context). Validators verify ZK proofs (proof-v2 or proof-v3) or mesh verification snapshots.
Scoring combines: (1) model base utility from active parameter count, context length, quantization quality, and generation quality; (2) throughput (tokens/second) raised to a configurable power; (3) TTFT latency relative to peer medians; (4) demand bonus based on organic traffic volume; (5) TEE attestation bonus if applicable. Miners failing proof verification are immediately placed on probation (EMA halved or zeroed for binding violations). Missing canary obligations trigger availability probation.
Hot-capacity audits (GPU workload proofs) gate miners with repeated failures from scoring. EMA decays to zero for undiscovered/unreachable miners. Emissions are distributed via model-bucketed weights with configurable burn fraction sent to the subnet owner UID.
The sections above were auto-generated from the GitHub repository and may not reflect the latest changes. View repository
FAQs were auto-generated from the GitHub repository and may not reflect the latest changes.
Holder & total-staked metrics as of 2h ago (hourly snapshot)
Recommended VRAM 48 GB (A6000/A40/L40S). CUDA 12.8+ required. SSD storage required for model weights and Merkle tree cache. Minimum 8 GB swap. Supported GPU tiers: 24 GB (RTX 4090, L4, A10), 32 GB (RTX 5090), 48 GB (A6000, L40S), 80 GB (A100, H100), up to 288 GB (B300 Blackwell Ultra).
No GPU needed. Modern multi-core CPU recommended; hard-proof verification is CPU-intensive. SSD storage required. For validators with more than 8 CPU cores, set VERATHOS_PCS_V2_THREADS=16 or 32.
One-command installer (recommended). Alternatively, clone the repo manually.
curl -fsSL https://verathos.ai/install.sh | bash
Manual install: clone repository and run miner setup script which creates venv, installs dependencies, and checks GPU compatibility.(optional)
git clone https://github.com/verathos-ai/verathos.git && cd verathos && bash scripts/setup_miner.sh
Create a new Bittensor wallet for the miner.
btcli wallet create --wallet.name miner
Register on Subnet 96 (requires staking TAO).
btcli subnet register --wallet.name miner --netuid 96 --subtensor.network finney
Show your EVM address and SS58 mirror for funding gas fees.
python scripts/show_evm_info.py --wallet miner --hotkey default
Transfer a small amount of TAO to the EVM mirror address for gas fees.
btcli wallet transfer --dest <SS58_MIRROR> --amount 0.1 --subtensor.network finney
Run the guided interactive wizard to configure wallet, registration, HTTPS, PM2, and config.
verathos setup
Start the miner. HTTPS is required on mainnet. The miner auto-detects GPU, selects the best model, starts vLLM, and registers on-chain.
python -m neurons.miner --wallet miner --hotkey default --model-id auto --netuid 96 --subtensor-network finney --endpoint https://YOUR-PUBLIC-IP
Set up nginx with a self-signed TLS certificate for HTTPS (required on mainnet). Alternatively use Cloudflare Tunnel.
bash scripts/setup_https.sh
Run the miner under PM2 for production reliability (auto-restart, log rotation).(optional)
pm2 start ecosystem.config.js --only miner
One-command validator installer (recommended). Alternatively, clone the repo manually.
curl -fsSL https://verathos.ai/install.sh | bash -s -- --validator
Manual install: clone repository and run validator setup script.(optional)
git clone https://github.com/verathos-ai/verathos.git && cd verathos && bash scripts/setup_validator.sh
Create a new Bittensor wallet for the validator.
btcli wallet create --wallet.name validator
Register on Subnet 96.
btcli subnet register --wallet.name validator --netuid 96 --subtensor.network finney
Fund your EVM address (recommended for on-chain reportOffline votes). Optional but recommended.(optional)
python scripts/show_evm_info.py --wallet validator --hotkey default && btcli wallet transfer --dest <SS58_MIRROR> --amount 0.05 --subtensor.network finney
Set HuggingFace token to avoid rate limits when downloading tokenizers for proof verification.(optional)
export HF_TOKEN="hf_..."
Start the validator. Auto-registers EVM on startup and begins canary testing miners.
python -m neurons.validator --wallet validator --hotkey default --netuid 96 --subtensor-network finney
Run the validator under PM2 for production reliability.(optional)
pm2 start ecosystem.config.js --only validator