The Yield on On-Chain AI Proofs Just Went Ex-Dividend
Full zkML now produces tiny proofs for LLMs, but deployable DeFi and agent stacks converge on targeted verification, execution offload, and cross-chain actions.
In the long ledger of certification, every era chooses which seams to solder. Full circuitization—reducing an entire model to one proving booth—is the cathedral school: every neuron card-catalogued, every activation a votive candle, the whole edifice of computation rendered in a single circuit. DSperse takes the other trade. It targets strategically chosen subcomputations with zero-knowledge proofs instead of circuitizing the entire model, then enforces global consistency through audit, replication, or economic incentives[^claim_1182]. That is not a fallback; it is a design choice, one that matches how DeFi actually consumes inference—not as a liturgical act, but as a delivery ticket with an escrow clause.
The full-proof alternative, meanwhile, got brutally cheaper. NANOZK produces constant-size 6.9KB proofs and proves 52×–228× faster than prior ZKML systems while preserving exact model accuracy[^claim_1183]. ZK-DeepSeek shows a recursively composed zkSNARK framework, no trusted setup, that supports matrix multiplication, normalization, softmax, and SiLU, translating DeepSeek into a fully SNARK-verifiable model with constant-size proofs[^claim_1184]. PHAZE adds a certifiable early-exit mechanism from an arbitrarily deep model, using hashing and zkML to generate succinct proofs of correct execution for C(x,w)=y[^claim_1195]. These are weapon specs. The latency on that script is zero; it hits the target.
But proving every layer is not shipping an on-chain product. The deployable path for DeFi is gas-bounded inference with verified model updates. A decentralized on-chain learning framework for DeFi attack mitigation pushes gas-prohibitive training to Layer-2, propagates verified model updates to Layer-1, and runs low-latency inference inside smart contracts via Proof-of-Improvement, which verifies each decentralized micro update as a self-verifying training transaction[^claim_1185]. Quantization and loop-unrolling let contracts run logistic regression, SVMs, MLPs, CNNs, gated RNNs, and formally verified decision trees within the Ethereum block gas limit, bit-exact to off-chain models and proven in Z3[^claim_1186]. That is a concrete primitive for attack mitigation guards around DeFi surfaces.
Execution is also moving off-L1 to specialized VMs and coprocessors. WICAS uses Cosmos SDK and WebAssembly modules to execute AI inference across multiple blockchain nodes via interchain communication, enabling decentralized, on-device, model-agnostic inferences for smart contracts[^claim_1187]. Cartesi and Artela let developers write AI inference logic in Python and compile it for on-chain execution, while Chainlink’s AI Oracle covers the oracle pattern and frameworks like EZKL, Cairo+Giza, or Modulus zkML handle verifiable inference[^claim_1194]. For heavy models, the pattern is to commit to a model identity, run inference off-chain, generate a ZK proof of correct execution, and verify it on-chain—a flow now supported by ZK coprocessors like Axiom and Brevis and by AVS built on restaking markets that host GPU inference[^claim_1193]. The bond market in restaking has become a GPU rental ledger with proof of solvency.
Agent tooling sits on top of this verifiable execution layer. ElizaOS provides an open-source core brain and architecture for AI agents—data layer, LLM integration, extensible agent logic—with plugins for Solana, operating as an OS for on-chain AI personalities[^claim_1190]. GOAT, developed by Crossmint, gives those agents a unified library of on-chain actions across more than 30 chains, supporting multiple languages and at least five popular agent frameworks, so a developer can write once and equip agents for USDC payments, Uniswap trades, and Polymarket bets[^claim_1191]. AgentKit keeps the model layer decoupled with a modular, model-agnostic architecture[^claim_1192]. Governance is not an afterthought: a LangChain-based multi-agent architecture stores and verifies every perception–conceptualization–action cycle on a permissioned blockchain, with a three-agent stack and high-impact decisions authorized through Model Context Protocol governance[^claim_1188]. A five-layer foundation extends this with DePIN physical infrastructure, W3C DIDs and reputation capital, RAG and MCP cognitive tooling, account abstraction for settlement, and Agentic DAOs for collective governance[^claim_1189].
The consequence is a layered stack, and it reads like a structured product. Full zkML and coprocessors supply verifiability; specialized VMs and WASM interchain runtimes supply execution; agent frameworks supply autonomous interaction with DeFi and governance systems. The next fight is not whether you can prove a model—NANOZK, ZK-DeepSeek, and PHAZE already prove you can. It is which slices a protocol chooses to verify and which incentives enforce the rest. The yield on proof-of-computation just went ex-dividend; the real coupon is the incentive schedule.
Provenance ledger
8 span-verified · 6 web-cited8 claims below are locked to a verbatim span re-verified against the source. The remaining 6 are web citations: the URL was checked, but the excerpt is the researcher's summary and was not re-derived from the page. Citation markers in the text jump here.
[1] DSperse introduces a modular framework for distributed machine learning inference that performs *targeted verification* of strategically chosen subcomputations using zero-knowledge proofs, instead of fully circuitizing the entire model, with verification of these "slices" enforced via audit, replication, or economic incentives. span-verified
“DSperse is a modular framework for distributed machine learning inference with strategic cryptographic verification. Operating within the emerging paradigm of distributed zero-knowledge machine learning, DSperse avoids the high cost and rigidity of full-model circuitization by enabling targeted verification of strategically chosen subcomputations. These verifiable segments, or ‘slices’, may cover part or all of the inference pipeline, with global consistency enforced through audit, replication,
3f76c4599e0614855c6ee74308e9fde52427b04d387e5fda14c3ddcbf26dbf23 [2] NANOZK achieves cryptographically verifiable LLM inference via layerwise zero-knowledge proofs, producing constant-size proofs of size 6.9KB and achieving 52×–228× faster proving than prior ZKML systems while preserving exact model accuracy. web-cited
“NANOZK enables practical, cryptographically verifiable LLM inference via layerwise zero-knowledge proofs, producing constant-size proofs (6.9KB) and 52×–228× faster proving than prior ZKML systems while preserving exact model accuracy.”
This excerpt was not re-derived from the source page, and may paraphrase or condense it. Check the source before relying on it.
[3] A zero-knowledge framework for verifiable inference of deep models (including matrix multiplication, normalization, softmax, and SiLU) is constructed using recursively composed zero-knowledge proofs, requires no trusted setup, and yields succinct non-interactive arguments of knowledge with constant-size proofs via the Fiat–Shamir heuristic; the framework is demonstrated by translating the DeepSeek model into a fully SNARK-verifiable version named ZK-DeepSeek. span-verified
“We introduce a zero-knowledge framework capable of verifying deep learning inference without exposing model internal parameters. Built on recursively composed zero-knowledge proofs and requiring no trusted setup, our framework supports both linear and nonlinear neural network layers, including matrix multiplication, normalization, softmax, and SiLU. Leveraging the Fiat-Shamir heuristic, we obtain a succinct non-interactive argument of knowledge (zkSNARK) with constant-size proofs. To demonstrat
5d4460606c61f551fc7e093344d0e8045dccf810e853ae541f4952c0d45171ea [4] An on-chain decentralized learning framework for DeFi attack mitigation performs gas-prohibitive training computation on a Layer-2, propagates verified model updates back to Layer-1, and enables gas-bounded, low-latency inference inside smart contracts by using a Proof-of-Improvement (PoIm) protocol that verifies each decentralized micro update as a self-verifying training transaction. span-verified
“We present the first decentralized, fully on-chain learning framework that: (i) performs gas-prohibitive computation on Layer-2 to reduce cost, (ii) propagates verified model updates to Layer-1, and (iii) enables gas-bounded, low-latency inference inside smart contracts. A novel Proof-of-Improvement (PoIm) protocol governs the training process and verifies each decentralized micro update as a self-verifying training transaction.”
2c0dba087a9a3238c8ee6eaf2960b676e65e609f9798c50f7fdca5537190e397 [5] The same DeFi-focused on-chain learning framework uses quantization and loop-unrolling techniques to support inference for logistic regression, SVMs, MLPs, CNNs, and gated RNNs, and also formally verified decision tree inference, all within the Ethereum block gas limit while remaining bit-exact to off-chain counterparts, with correctness formally proven in Z3. span-verified
“We develop quantization and loop-unrolling techniques that enable inference for logistic regression, SVM, MLPs, CNNs, and gated RNNs (with support for formally verified decision tree inference) within the Ethereum block gas limit, while remaining bit-exact to their off-chain counterparts, formally proven in Z3.”
404fa1449d804f6fb7eaa4f02c8e428aa6cb10c01d9dbf945b47cf66a51e7cc9 [6] WICAS (WASM-Powered Interchain Communication for AI Enabled Smart Contracts) uses Cosmos SDK and WebAssembly modules to execute AI inference across multiple blockchain nodes, enabling decentralized, on-device, model-agnostic inferences for smart contracts via interchain communication. span-verified
“Our paper introduces an innovative framework that integrates blockchain technology, particularly the Cosmos SDK, to facilitate on-chain AI inferences. This system, built on WebAssembly (WASM), enables interchain communication and deployment of WASM modules executing AI inferences across multiple blockchain nodes. In our study, we introduce a framework designed to enable decentralized on-device AI model agnostic inferences for smart contracts. To address the above, we propose WASM-Powered Interc
4c111134210b3d5fbc4fd688290148295afef7d59c76421fd798aaf3759f4af9 [7] A LangChain-based multi-agent architecture is proposed where every perception–conceptualization–action cycle is stored and verified on a permissioned blockchain, with a three-agent stack (Perception, Conceptualization, Action) and a LangChain-based agent stack, and decisions with high impact are monitored and authorized via a blockchain layer of governance implemented through the Model Context Protocol (MCP). web-cited
“In this paper, an agentic AI architecture is proposed that is monitored through blockchain, and every perception-conceptualization-action cycle is stored and verified on a permissioned blockchain. The paper suggests a single architecture model comprising of LangChain-based multi-agent system with a permissioned blockchain to guarantee constant monitoring, policy enforcement, and immutable auditability of agentic action. It is based on a three-agent stack (Perception, Conceptualization, Action)
This excerpt was not re-derived from the source page, and may paraphrase or condense it. Check the source before relying on it.
[8] A five-layer blockchain-based foundation for autonomous AI agents is proposed: Physical Infrastructure via DePIN protocols for hardware and energy, Identity & Agency via W3C DIDs and reputation capital, Cognitive & Tooling via RAG and MCP, Economic & Settlement via account abstraction for financial autonomy, and Collective Governance via Agentic DAOs for multi-agent coordination. span-verified
“We propose a five-layer architecture: (1) Physical Infrastructure (hardware & energy) through DePIN protocols; (2) Identity & Agency establishing on-chain sovereignty through W3C DIDs and reputation capital; (3) Cognitive & Tooling enabling intelligence via RAG and MCP; (4) Economic & Settlement ensuring financial autonomy through account abstraction; and (5) Collective Governance coordinating multi-agent systems through Agentic DAOs.”
605e16698fa586a3fe1e2dafe6ee091cebf01e4389a7ae903a5361f6d89d9949 [9] ElizaOS is an open-source framework that provides a core "brain" and architecture for AI agents by combining a data layer, LLM integration, and extensible agent logic, and includes plugins for Solana and other platforms, effectively functioning as an operating system for building on-chain AI personalities. web-cited
“This success pushed the team (led by Stanford alum Shaw Walters) to rebrand Ai16z into ElizaOS, positioning it as a general-purpose framework for creating and managing autonomous agents. ElizaOS (now open-source) provides the core ‘brain’ and architecture for AI agents — combining a data layer, LLM integration, and an extensible agent logic — with plugins for Solana and other platforms. In short, it’s an operating system for building on-chain AI personalities.”
This excerpt was not re-derived from the source page, and may paraphrase or condense it. Check the source before relying on it.
[10] GOAT, an open-source toolkit developed by Crossmint, provides a unified library of on-chain actions that allows AI agents to interact with smart contracts across more than 30 different chains in a standardized way, supports multiple programming languages, and integrates with at least five popular agent frameworks to enable write-once cross-chain capabilities such as USDC payments, Uniswap trades, and Polymarket bets. web-cited
“Another pillar of Solana’s AI stack is GOAT, an open-source toolkit developed by Crossmint. GOAT’s ambition is to be the universal adapter between AI agents and any blockchain application. GOAT provides a unified library of on-chain actions, enabling agents to seamlessly interact with smart contracts across 30+ different chains in a standardized way. It supports multiple programming languages and at least five popular agent frameworks. In other words, GOAT lets developers ‘write once’ and equip
This excerpt was not re-derived from the source page, and may paraphrase or condense it. Check the source before relying on it.
[11] AgentKit offers a modular, model-agnostic architecture that supports multiple AI frameworks, decoupling developers from any single AI model provider. web-cited
“AgentKit supports multiple AI frameworks and offers a modular, model-agnostic architecture, freeing devs from being tied to any single AI model provider.”
This excerpt was not re-derived from the source page, and may paraphrase or condense it. Check the source before relying on it.
[12] Verifiable AI inference using zero-knowledge proofs can be implemented by committing to a model identity (e.g., hash of weights), running inference off-chain, generating a ZK proof that the output corresponds to correct execution of that model on a given input, and verifying this proof on-chain; by 2025–2026, this pattern is supported by ZK coprocessors like Axiom and Brevis, and by Actively Validated Services (AVS) built on restaking markets that host GPU inference. span-verified
“The most direct cryptographic approach is to run inference off-chain (for speed and cost efficiency) and submit a compact zero-knowledge proof on-chain that attests the computation was performed correctly… In practice, this pattern works as follows: 1. Commit to model identity and version (for example, a hash of weights or a signed attestation). 2. Run inference off-chain using the committed model and input. 3. Generate a ZK proof that the output corresponds to correct execution of that model o
00ee04c11f3b480e64ff284e0fdad28978c111da720d0b0448b5a86800f41dc6 [13] An on-chain AI inference system can be architected by executing a model’s forward pass directly in the blockchain execution environment with model weights and inputs stored on-chain, or by using oracle patterns such as Chainlink’s AI Oracle, or by leveraging specialized virtual machines like Cartesi and Artela that allow AI inference logic to be written in languages like Python and compiled for on-chain execution; a zkML framework such as EZKL, Cairo+Giza, or Modulus zkML is then used when verifiable inference is required. span-verified
“On-chain AI inference executes a machine learning model's forward pass directly within a smart contract or blockchain's execution environment. The model weights and input data are stored on-chain, and the computation is performed by the network's validators or a designated prover network. This ensures verifiable, trustless execution where the result can be cryptographically proven. For an oracle pattern, use a framework like AI Oracle from Chainlink… Cartesi and Artela provide specialized virtu
4646e22aed710405bda12cb2c3b9ae35c7055b46d93b2254871c5174bed1bd9c [14] PHAZE is a framework that uses cryptographic hashing and zero-knowledge machine learning to achieve low-latency inference via a certifiable early-exit mechanism from an arbitrarily deep model, using zkML to generate succinct proofs π of correct execution of an ML model’s inference computation C(x, w) = y where x is public input, w is a private witness (e.g., model parameters or activations), and y is public output. web-cited
“In this work, we propose PHAZE [1], a novel framework built on cryptographic techniques like hashing and zero-knowledge machine learning (zkML) to achieve low latency inference, via a certifiable, early-exit mechanism from an arbitrarily… zkML: An application of ZKPs for generating a succinct proof, π, of the correct execution of an ML model’s inference computation, C(x, w) = y, where x ∈ L is a public input in a corpus L (e.g., training dataset), w is the private witness (e.g., model parameter
This excerpt was not re-derived from the source page, and may paraphrase or condense it. Check the source before relying on it.
Sources
- https://arxiv.org/html/2508.06972v3
- https://openreview.net/forum?id=zNTAvn3sct
- https://arxiv.org/abs/2511.19902
- https://arxiv.org/abs/2510.16024
- https://arxiv.org/html/2502.17604v1
- https://arxiv.org/html/2512.20985v1
- https://arxiv.org/abs/2602.14219
- https://medium.com/@grigon/ai-agents-and-the-future-of-crypto-how-intelligent-systems-are-shaping-blockchain-in-2025-9dae972f7039
- https://www.blockchain-council.org/blockchain/verifiable-ai-inference/
- https://chainscorelabs.com/guides/ai-llms-and-machine-learning-in-web3/on-chain-ai-inference/how-to-architect-an-on-chain-ai-inference-system
- https://ml4physicalsciences.github.io/2025/files/NeurIPS_ML4PS_2025_180.pdf