encrypted on-chain AI inference // proof-of-model // blockdag
KERYX
Verifiable On-Chain AI Inference
Ask a question in a transaction. A GPU miner answers with an open model. The answer lives on-chain, sealed to you — and every node checks it really came from that model.
keryx // on-chain inference
$ AiRequest → Qwen3.8-27B — 2.0 KRX, sealed
# "Should this agent rebalance to 60% stablecoins?"
✓ request included in the DAG — prompt sealed to the tier's miners
✓ picked up by a bonded miner — model resident in VRAM
✓ inference complete — answer sealed back to the requester
✓ AiResponse on-chain — sealed answer + computation commitment, immutable
✓ audit passed — drawn points checked against the model's weights by every node
$ answer: "Yes. Volatility is rising and the trend is down — rebalance now."
the problem
The Centralized Black Box
Three corporations control the filters of global AI. On-chain agents can't run local models. They need a decentralized inference layer.
// threat
Silent Censorship
AI providers quietly modify model outputs to align with corporate policies. No transparency, no audit trail, no recourse.
// keryx
Sovereign AI
The model runs across thousands of sovereign miners. No kill switch. Intelligence becomes a public infrastructure.
// threat
Prompt Surveillance
Every query passes through centralized servers. Your questions, strategies, and private data — logged, analyzed, monetized.
// keryx
Encrypted Inference
No central server, no logs. Only the miners serving your tier can open the prompt, and the answer is sealed back to you — the public chain sees ciphertext.
// threat
Unverifiable Answers
A hosted API can quietly swap in a cheaper model or serve a cached reply. You get text back, and no way to know what produced it.
// keryx
Verifiable Inference
Every answer commits to the computation that produced it and is audited on-chain against the model's weights. Fake the model and your bond is on the line.
// threat
Single Point of Failure
One outage, one policy change, one revoked API key — and every agent built on the provider goes dark.
// keryx
Enforced Availability
Miners lock 20% of every block as a bond. Prove a tier and fail to serve it, or fail an audit, and bond outputs burn — three strikes suspends you for 24h.
how it works
On-Chain Inference
Your question is a transaction only the serving miners can read. Your answer is on-chain, sealed to you. The miner who serves it is bonded, and every node audits the computation behind the answer.
01
Request
User or AI agent submits an AiRequest with model ID and fees. The prompt is sealed to every miner of the requested tier; the chain only carries ciphertext.
02
Inference
Eligible miners — those that have proven the requested tier within the last ~5 minutes — run the model and publish sealed answers, each committing to the computation that produced it.
03
Audit & Bond
Every answer is audited: the miner opens randomly drawn points of its computation and every node checks them against the model's weights. The 20% bond stays timelocked for 792,000 blocks (~22h); a miss or a skipped audit burns bond outputs, an invalid opening burns all of the burnable bond, and a third strike suspends the payout for 24h.
04
Settlement
The sealed answer is on-chain and immutable. The request's reward is drawn among the miners whose answers passed their audit, and minted to the winner once final; the bond returns when its timelock expires.
> on-chain inference lifecycle
AiRequest tx
reward locked in vault
→
AiResponse tx
sealed answer + trace
→
AiOpening tx
audit checked by every node
→
reward drawn
minted to the winner
> probation — why rotating identities does not pay
Strikes and suspensions follow the payout address, not the hot escrow key — so a miner can rotate keys on a rig freely, but cannot shed a record by starting a fresh address. A new identity spends 504,000 blocks (~14h) on probation, earning the floor tier rate of 60% whatever tier its hardware proves. Walking away from a strike costs up to 40% of the miner cut for fourteen hours; absorbing it costs less. The unpaid remainder is burned, so nobody profits from anyone else's probation.
don't trust, verify
Verifiable Inference
Every answer on Keryx is audited by consensus. Not by a committee, not by an oracle service: by every node, against the weights of the model the miner claims to have run.
01
Commit
While generating, the miner records the model's intermediate computation and publishes a commitment to it with the answer, before anyone knows what will be checked.
02
Draw
A later block draws the points to check. Nobody can predict them when the answer is built, so the whole computation has to be real.
03
Open
The miner publishes an AiOpening revealing the drawn values. The computation is bound to this request and this answer, so it cannot be borrowed from another one.
04
Verify
Every node checks the opening against the model's pinned weights. Pass, and the miner stays in the reward draw. Skip it and take a strike; send a false one and the bond burns.
> an answer you can act on
Re-running a model on every node is impossible, and GPUs never agree to the last bit. Keryx sidesteps both: it checks a random sample of the computation, within tolerances designed for honest hardware, and puts the miner's bond behind every answer. An agent that reads a Keryx answer does not have to take the miner's word for which model produced it.
supported models
Verified AI Models
A fully uncensored lineup — no corporate filters, no refusals. Every model is identified on-chain by its model_id, the digest of its IPFS CID, and anchored by a per-tier weight Merkle root checked in every block's Proof-of-Model. A miner cannot fake which model it holds. Each request costs a fixed minimum price per model, whatever the answer length, plus the 0.3 KRX network fee; requesters can raise the priority_fee to be included sooner.
// 9B params · uncensored
Qwen3.5 9B
0.5 KRXmin / request
model_id: bd34568c...eb5710
Light and unfiltered. Runs on an 8 GB GPU — the entry tier for high-frequency agent calls and synthetic workloads.
// 9B params · uncensored
GLM-4 9B
1.0 KRXmin / request
model_id: fa2f13be...f2140a
Balanced reasoning and speed, no corporate filters. Suitable for complex queries, on-chain agent decisions, and multi-step logic.
// 12B params · uncensored
Gemma-4 12B
1.5 KRXmin / request
model_id: 39998404...617cc6
Unfiltered mid-tier for 16 GB cards. Strong general reasoning and instruction-following, sitting between the 9B tier and Qwen3.8-27B.
// 27B params · uncensored
Qwen3.8 27B
2.0 KRXmin / request
model_id: 73740b44...c96fb3
High-fidelity reasoning at scale, unrestricted. Deep analysis, code generation and long-context understanding on a single 24 GB card.
// 48B params (MoE) · uncensored
Kimi-Linear 48B
2.5 KRXmin / request
model_id: 3dc09358...dffddb
State-of-the-art open MoE, fully unfiltered — 48B total, 3B active per token. The Q4_K_M quant fits a single 32 GB card. Reserved for the most demanding autonomous agent workflows.
> gpu_tiers — pick your flag
--very-lightQwen3.5-9B (uncensored)8 GB+ VRAM
--lightGLM-4-9B (uncensored)12 GB+ VRAM
(default)Gemma-4-12B (uncensored)16 GB+ VRAM
--highQwen3.8-27B (uncensored)24 GB+ VRAM
--very-highKimi-Linear-48B (uncensored)32 GB+ VRAM
> priority_fee
Requesters can bid above the minimum fee: block templates favour higher-fee transactions, so a higher priority_fee gets the request on-chain sooner. Every fee is paid in $KRX, creating direct, measurable buy pressure from actual AI usage.
why trust the miner
Proof-of-Model
Keryx's proof-of-work isn't arbitrary hashing — it's the model itself. To win a block, a miner's GPU must actually hold a full AI model in memory.
01
Possession
Mining requires a model's weights resident in VRAM. No idle hashing on a bare GPU — the work is the model.
02
The Weight-Walk
The proof-of-work walks the resident weights — each read's location derived from the last. A partial copy can't precompute or stream fast enough: miss a fraction of the weights and you fall far behind.
03
One GPU = One Model
The largest model your VRAM holds sets your tier — from Qwen3.5-9B on an 8 GB card to Kimi-Linear-48B on a 32 GB card. Heavier tier, larger block reward.
04
Trustless
Verification is byte-exact and fully deterministic: every node re-executes the whole walk from the block's proof against a per-tier weight Merkle root. Pool-safe and fork-proof — no trust in the miner.
> proven, not promised
PoM proves a miner holds the model, byte-exactly, at the consensus level — the service bond proves they answer, and the audits prove the answer came from the model. All three are re-derived from the chain by every node, with no attestation service and no committee in the path. The network's capacity is a floor you can read off the chain, not a figure its operators assert.
use cases
Who Needs Keryx?
Whether for humans seeking truth without filters or autonomous agents operating on-chain, Keryx is the trustless backbone of decentralized intelligence.
>
Autonomous On-Chain Agents
Solana and Ethereum AI agents are, today, fully centralized via Web2 APIs. Smart contracts are deterministic — they cannot reason, interpret language, or make decisions, so the moment an agent has to think it calls OpenAI or Anthropic and inherits their kill switch. With Keryx, an agent broadcasts an AiRequest on-chain, a miner executes the inference, and the result comes back as an on-chain AiResponse — no HTTP call, no API key, no corporate gateway. The serving miner has proven on-chain that they hold the model they answered with, and forfeits collateral if they refuse to answer or fail the audit of their answer. The chain is the oracle.
>
Encrypted Inference
Live on mainnet: every request is sealed end to end. The prompt is encrypted to the miners of the requested tier and the answer comes back encrypted to the requester — nobody else can read either, and the plaintext never appears on-chain in any form. Model, fee and responders stay public, so the service bond still checks that every request is answered, and the signed answer cannot be altered once published.
>
Uncensored Knowledge
Legal, medical, or political queries without corporate filters. A neutral AI that answers factually regardless of the topic.
infrastructure
Tech Stack
rusty-kaspa fork
GHOSTDAG BlockDAG at 10 BPS. Proof-of-Model: mining requires a full model resident in GPU VRAM.
inference engine
In-process GGUF inference engine. Runs 5 verified models (9B → 48B) natively on GPU. Model identity = the model_id from its IPFS CID; possession proven by the per-tier weight Merkle root in every block.
proof-of-model
The proof-of-work walks the model weights resident in VRAM, each read located by the previous one — holding the full model is the only way to keep up. Every node re-executes the whole walk from the block's proof against a per-tier weight Merkle root, byte-exact and fully deterministic. Pool-safe and fork-proof, with no trust in the miner.
encrypted inference
Prompts sealed to the escrow keys of the tier's miners (secp256k1 ECDH + ChaCha20-Poly1305), answers sealed back to the requester and carried inline in the AiResponse, signed by the responder. The chain only ever sees ciphertext.
verifiable inference
Each AiResponse commits to a Merkle root over the model's intermediate computation. A later block draws the points to open; the miner answers with an AiOpening that every node checks against the model's pinned weights. A skipped audit is a strike, an invalid one burns the bond.
tokenomics
$KRX Economics
Designed for long-term scarcity. Every transaction destroys value. Every block splits its reward between the miner, the service bond and R&D; fees and modifier shortfalls are burned.
fee burn
100% of transaction fees are permanently destroyed — fees reduce circulating supply on every block.
min fee
0.3 KRX minimum per standard transaction. Spam-resistant and economically sound — every on-chain action has a real deflationary cost.
Block Reward Split
75% — Miner
Paid to the miner's wallet on block confirmation, scaled by the tier and holder multipliers; whatever they scale away is burned
20% — Service bond
Locked as a service bond, recovered when the ~22h timelock expires
5% — R&D
Allocated to protocol research, model maintenance, and development
execution
Roadmap
✓ phase_1Genesis — Completed
- ☑Full Kaspa → Keryx rebrand (binary, ports, address prefix, genesis block)
- ☑KeryxHash (KERYX_MATRIX_SALT + wave_mix)
- ☑Inference commitment in every coinbase (format validation)
- ☑TinyLlama-1.1B inference in miner (candle-transformers)
- ☑Explorer + API (real-time, PostgreSQL indexed)
- ☑Richlist, top miners on explorer
- ☑Web wallet integration
✓ phase_2Economy — Completed
- ☑20% escrow routing (CSV-locked, auto-claim in miner)
- ☑AiRequest / AiResponse transactions
- ☑P2P attack mitigations (autoban)
- ☑Escrow hard-lock: consensus-enforced relative timelock on the bond
- ☑Transaction fee burn (100% of fees destroyed)
- ☑Minimum transaction fee: 0.3 KRX
✓ phase_3Multi-Model Oracle — Deployed (DAA 15,550,000)
- ☑Multi-model support: TinyLlama-1.1B, DeepSeek-R1-8B, DeepSeek-R1-32B, LLaMA-3.3-70B
- ☑Per-model inference_reward minimums enforced at consensus level
- ☑priority_fee separate from inference_reward (burned vs miner-paid)
- ☑Token-count surcharge (0.05 KRX per 64-token increment), replaced by fixed per-model prices at H14
- ☑Model capability announcement in coinbase extra_data (/ai:cap:)
- ☑IPFS result storage: AiResponse stores CIDv0 instead of inline text (sealed answers travel inline since H14)
- ☑model_id = the digest carried in the weight file's IPFS CIDv0 (root of its chunked DAG)
- ☑IPFS for model weight distribution (miner downloads from Keryx IPFS gateway)
- ☑CUDA inference support (candle-core, VRAM-aware multi-model placement)
✓ phase_4Proof-of-Model & Holder Economics — Deployed (DAA 37,780,000)
- ☑PoM: KeryxHash matrix-multiply replaced by a data-dependent walk over the resident model weights (possession proof, one GPU = one tier)
- ☑Byte-exact deterministic verification via per-tier weight Merkle root R_T (pool-safe, fork-proof)
- ☑Zero-copy: PoM walk shares the inference weights resident in VRAM (no second copy)
- ☑Launch lineup: four tiers (Gemma-3-4B, Dolphin-3.0-8B, Qwen3-32B, LLaMA-3.3-70B), tier-reward 82/88/94/100%, delta burned
- ☑Holder-reward: miner cut scaled by KRX held relative to windowed production, delta burned
- ☑CUDA mining engine (PoM walk on a custom CUDA kernel)
- ☑Five-tier lineup (H2 — DAA 38,951,445): Qwen3-1.7B, Gemma-3-4B, Dolphin-3.0-8B, Qwen3-32B, LLaMA-3.3-70B Q2; tier-reward 68/76/84/92/100%
- ☑GGUF lineup and coin-age holder balance (H4 — DAA 54,766,000): new lineup up to Kimi-Linear-48B; holder ratio on the coin-age effective balance, nine brackets up to 90 days
- ☑Hardened walk (H5 — DAA 59,009,037): every byte of each chunk load-bearing; parallel-block cap (N=20)
- ☑Matrix walk and 9B–48B lineup (H6 — DAA 76,316,623): integer matrix walk; Qwen3.5-9B, GLM-4-9B, Gemma-4-12B, Qwen3.6-27B, Kimi-Linear-48B, 8 GB tier-0 floor, tier-reward 60/70/80/90/100%; escrow delegation mandatory and bond timelock raised to 792,000 DAA
- ☑Full re-walk and reward vault (H8 — DAA 79,210,000): verification re-executes the whole walk over 1 KiB weight tiles; inference rewards held in a keyless vault and minted to the winning responder
phase_5Scaling & Sovereign Intelligence — In progress
- ☑Stateful models with persistent memory: earlier exchanges travel with each request, so a request can build on earlier answers
- ☑Network access: live web results fetched for a request and handed to the model, so answers can use current data
- ☑Encrypted inference (H14 — DAA 121,985,000): the prompt sealed to the miners of its tier and the answer sealed back to the requester; the chain keeps only the metadata
- ☑Verifiable inference (H15 — DAA 140,115,000): every answer commits to its computation trace and is audited on-chain at random points against the model's weights, without requiring identical outputs across GPUs
- ☐The network is the model: a large model split into shards served by several miners, each holding one slice resident in VRAM, so the network serves models no single card can hold
phase_6The Cross-Chain Oracle
- ☐Ethereum bridge: smart contract → AiRequest → Keryx → result → Ethereum callback
- ☐Solana bridge (same pattern)
- ☐On-chain agent demo: autonomous Ethereum agent calling Keryx for decisions
- ☐Model query API: submit a request and read its answer programmatically, so agents and applications can use Keryx models without running a node
Intelligence belongs to no one.
"Intelligence is the message. Keryx is the messenger."
// fork. mine. liberate. //