ERC-7992 and Keryx Split Verifiable AI Into Contracts and Settlement Layers

Verifiable ML inference on-chain is undergoing a schism, splitting into two complementary strata: standardized contract interfaces and protocol-native settlement. ERC-7992 gives Ethereum smart contracts a uniform way to accept zero-knowledge attestations of model outputs. Keryx builds a dedicated L1 that turns inference into a slashable, economically settled work unit. Together, they define the infrastructure stack for AI×crypto—a system that feels like watching the early days of TCP/IP, but with more GPU heat and less idealism.

ERC-7992 standardizes how contracts reference ML models and verify inferences[^claim_1911]. It defines a registry that binds a modelId to a ModelCommitment containing hashes of model weights/architecture, proving circuit/AIR, verifying key, and a proofSystemId. The verifyInference(modelId, inputCommitment, output, proof) interface must revert on failure and supports Groth16, Plonk, or STARK without ABI changes[^claim_1911]. That pluggability means a single contract can accept proofs from different proving systems—critical for DeFi risk engines or prediction markets that might switch proving backends like a Wall Street trader rotating sectors. The standard also adds replay protection: inputCommitment must be domain-separated and should include a nonce/salt when single-use or non-deterministic behavior is possible[^claim_1912]. An optional storage extension persists verified inference records for auditability and deterministic settlement[^claim_1912]. For protocols like Polymarket or Aave, this means inference-based oracles can be audited and settled without locking into one proving system—a kind of financial diversification for truth.

Keryx takes a different approach: it makes AI inference a first-class operation on its own L1. Its AiRequest transaction carries a 32-byte model_id, max_tokens, inference_reward, and a separate burned priority_fee, plus a token surcharge of 0.05 KRX per 64-token increment[^claim_1913]. Miners declare loaded models via coinbase extra_data using /ai:cap:<model_ids>[^claim_1913]. The AiResponse stores only a 34-byte CIDv0 on-chain while the full output lives on IPFS; the on-chain payload is fixed at 78 bytes and includes request_hash, challenge_window_end, response_ipfs_cid, and response_length[^claim_1914]. This compact on-chain footprint is designed for deterministic settlement—the full output can be fetched off-chain, but the commitment is enough for challenge logic. It’s like a hardboiled spy novel describing a dead drop: the message is tiny, but the payload is everything.

Keryx’s Optimistic Proof of Inference (OPoI) uses a 36,000-block challenge window (roughly one hour at 10 BPS) and routes 20% of the block subsidy into a CSV-locked escrow[^claim_1915]. If fraud is proven, the challenger can obtain the escrow. But on-chain slashing is temporarily disabled pending a deterministic redesign[^claim_1915]. That’s a critical caveat: the economic security of inference is not yet fully live. The protocol’s Phase 4 Proof-of-Model (PoM) hardfork replaces the matrix-multiply PoW with a data-dependent walk over resident model weights, proving possession of the full model in VRAM[^claim_1916]. PoM is byte-exact and deterministic, and maps GPU tiers to specific model sizes—a 4 GB card for Qwen3-1.7B, a 32 GB card for LLaMA-3.3-70B (Q2)[^claim_1916]. The miner implementation is Rust/CUDA-based, requires NVIDIA GPUs with SM 7.5+ and driver ≥ 535, and shares resident weights between PoM and inference to avoid a second VRAM copy[^claim_1917]. This is the kind of hardware stratification that makes you wonder if we’re building a new feudal system, where GPU lords hold the keys to the kingdom.

For blockchain developers, verifiable AI is converging on three layers: standardized verifier interfaces (ERC-7992), operator-side execution frameworks with model commitments (Keryx’s PoM), and settlement layers that turn outputs into economically accountable events (OPoI). ERC-7992 is immediately usable on Ethereum today for any contract that needs to verify an inference proof. Keryx offers a more integrated stack but comes with the caveat that its slashing mechanism is not yet active—the economic guarantees are aspirational. Watch for ERC-7992 adoption in DeFi oracle designs and for Keryx’s slashing redesign to go live, which would make it the first L1 with fully economically enforced AI inference. The yield on trust just went ex-dividend.