Data is a commodity in Web3. Every node replays the same state transitions, making raw blockchain data cheap and universally accessible. This commoditization destroys value for infrastructure providers like Chainlink or The Graph, forcing them into a race-to-the-bottom on price.
ai-x-crypto-agents-compute-and-provenance
Blog
Why Verifiable Computation is the Foundation of Web3's Data Economy
Raw data is a commodity; verifiable insight is the asset. We argue that without cryptographic proof of computation—via zkML and systems like EigenLayer AVS—tokenized data markets are structurally doomed to fail.
introduction
THE DATA
Introduction: The Data Commoditization Trap
Web3's current data infrastructure is a commodity, creating a trust gap that verifiable computation solves.
The trust gap emerges when applications need data outside the chain. Oracles and bridges like Pyth and Wormhole become centralized trust points, reintroducing the counterparty risk that decentralization aimed to eliminate. The data is verifiable, but its delivery mechanism is not.
Verifiable computation is the foundation. It shifts trust from entities to cryptographic proofs. Instead of trusting LayerZero's relayers, you verify a zero-knowledge proof of their work. This transforms data from a cheap commodity into a cryptographically assured asset.
Evidence: The $625M Wormhole exploit in 2022 was a bridge failure, not a blockchain failure. It proved that trusting a multisig for cross-chain data is a systemic risk that verifiable computation eliminates.
thesis-statement
THE FOUNDATION
Core Thesis: Computation is the Asset, Data is the Fuel
Verifiable computation transforms raw data into a monetizable asset by guaranteeing its processing integrity.
Computation is the asset because trust in the output is the primary value. A blockchain's state is the result of deterministic execution; the asset is the verifiable proof of correct computation, not the data itself.
Data is the fuel that powers this asset. Without high-integrity inputs from oracles like Chainlink or Pyth, even perfect computation produces worthless outputs. The data economy exists to feed the computation engine.
Web2 monetizes attention; Web3 monetizes truth. Platforms like Google profit from data aggregation. Protocols like EigenLayer and AltLayer profit from cryptographically verifying that data was processed correctly, creating a new revenue layer.
Evidence: The $30B+ Total Value Secured (TVS) in oracle networks demonstrates the market's demand for verifiable data feeds as foundational infrastructure for DeFi and on-chain AI.
key-trends
WHY VERIFIABLE COMPUTATION IS THE FOUNDATION
The Three Trends Making This Inevitable
The shift from trust-minimized consensus to trust-minimized execution is the next logical evolution, unlocking a new data economy.
01
The Problem: Opaque Off-Chain Compute is a Systemic Risk
Oracles like Chainlink and Pyth deliver data, but their aggregation logic is a black box. Bridges like LayerZero and Axelar rely on external attestation committees. This creates a $10B+ TVL attack surface where users must trust, not verify.
- Centralized Failure Points: A single bug or malicious actor in the off-chain component can drain entire protocols.
- Unverifiable Logic: You cannot audit the data sourcing or message validation process after the fact.
$10B+
TVL at Risk
0%
On-Chain Proof
02
The Solution: ZK Proofs for Any Program (zkVM)
Projects like Risc Zero, SP1, and zkSync's Boojum enable any computation—written in Rust, C++, or Solidity—to generate a cryptographic proof of correct execution. This moves the trust from entities to math.
- Universal Verifiability: A single on-chain verifier contract can check proofs for any application, from an UniswapX solver to a The Graph indexer.
- Cost Asymmetry: Generating a proof is computationally heavy (~2-10 seconds), but verifying it on-chain is cheap and constant time (~50k gas).
~50k
Gas to Verify
Any Code
Language
03
The Catalyst: AI Agents Demand Provable Work
On-chain AI agents and autonomous worlds require deterministic, verifiable execution environments. Without it, their actions are just promises. Verifiable computation turns AI outputs into on-chain state transitions with cryptographic guarantees.
- Provable Inference: An AI model's decision (e.g., a trade, a game move) can be proven correct relative to its weights and inputs.
- Sovereign Data Pipelines: Projects like Modulus and EigenLayer AVSs can offer verified data transformation, creating a new market for attested data streams beyond simple price feeds.
100%
Deterministic
New Market
Data Streams
deep-dive
THE TRUST LAYER
Deep Dive: From Oracles to On-Chain Provers
Blockchain's data economy shifts from trusted reporting to verifiable computation, moving the trust boundary from entities to code.
Oracles are a security liability. They introduce trusted third parties into trustless systems, creating central points of failure as seen in the Chainlink/Axie Infinity Ronin bridge hack. The oracle problem is a data availability and attestation problem.
On-chain provers solve attestation. Protocols like EigenLayer AVS operators and Brevis coChain ZK coprocessors generate cryptographic proofs of off-chain computation. The blockchain verifies the proof, not the data source, moving trust from the reporter to the verifier.
This enables new data primitives. Applications can request verified computations on historical states (e.g., a user's 30-day DEX volume) or real-world data feeds without relying on a single oracle's signature. This is the architecture behind UniswapX's intent-based fills and Aevo's options pricing.
The bottleneck is proving cost. Zero-knowledge proofs (ZKPs) from Risc0 or SP1 are computationally expensive. The trade-off is clear: pay for high-security, verifiable data or accept the lower-cost, higher-risk oracle model. The long-term trajectory favors provable computation.
ARCHITECTURAL FOUNDATIONS
The Trust Spectrum: Data vs. Computation
Compares trust models for data availability and execution, the core trade-offs in Web3 infrastructure.
| Core Metric / Capability | Data Availability (DA) Layer | Verifiable Computation (VC) Layer | Hybrid (DA + VC) System |
|---|---|---|---|
Trust Assumption | Honest majority of data availability committee | Cryptographic proof of correct execution (ZK/Validity) | Honest majority for DA + cryptographic proof for execution |
Data Integrity Guarantee | Data is available, not necessarily correct | Execution over data is provably correct | Data available & execution provably correct |
Primary Use Case | High-throughput data publishing (e.g., Celestia, EigenDA) | Trust-minimized execution & state transitions (e.g., zkEVMs, RISC Zero) | Optimistic & ZK Rollups (e.g., Arbitrum, zkSync) |
Settlement Finality Latency | Minutes to hours (for fraud proofs) | ~10-20 minutes (proof generation time) | Minutes (Optimistic) to ~20 minutes (ZK) |
Throughput (TPS) Focus | ~10,000+ TPS (data blobs) | ~100-1,000 TPS (proof generation bottleneck) | ~100-4,000 TPS (constrained by VC) |
Inherent Censorship Resistance | Weak (committee can withhold data) | Strong (proof validity is permissionless to verify) | Weak for DA, Strong for execution |
Key Enabling Tech | Data Availability Sampling (DAS), Erasure Coding | Zero-Knowledge Proofs (ZKPs), Fraud Proofs | Bridges (e.g., LayerZero, Across), Proof Systems |
Economic Security Cost | $1-5 per MB (blob fee) | $0.01-0.10 per million gas (proof cost) | $1-5 per MB + $0.01-0.10 per million gas |
protocol-spotlight
VERIFIABLE COMPUTATION
Architectural Spotlight: Who's Building the Foundation?
The ability to prove the correctness of off-chain computation is the bedrock for scaling and monetizing data in Web3.
01
The Problem: The Oracle Dilemma
Smart contracts are blind. They need external data (price feeds, randomness, API results) but must trust centralized oracles, creating a single point of failure and manipulation.
- Security Risk: Billions in DeFi TVL rely on a handful of data providers.
- Cost Inefficiency: Every node redundantly fetches the same data, paying for bandwidth and computation.
$10B+
TVL at Risk
~3-5
Dominant Oracles
02
The Solution: zkOracles (e.g., RedStone, Nil Foundation)
Prove that off-chain data was fetched and processed correctly using zero-knowledge proofs. The contract verifies a tiny proof, not the data itself.
- Trustless Data: Cryptographically guarantees data integrity and availability.
- Cost Scaling: Data providers compute once, prove it, and all chains verify cheaply.
~200KB
Proof Size
-90%
Gas Cost
03
The Problem: The L2 Scaling Bottleneck
Optimistic Rollups (Arbitrum, Optimism) have 7-day withdrawal delays because they assume honesty and need a window for fraud proofs. This kills capital efficiency and UX for cross-chain apps.
- Capital Lockup: Users and protocols wait a week to bridge assets.
- Fraud Proof Complexity: Building a decentralized network of verifiers is hard and slow.
7 Days
Withdrawal Delay
High
Trust Assumption
04
The Solution: zkEVMs (e.g., zkSync Era, Polygon zkEVM, Scroll)
Execute Ethereum transactions off-chain and post a validity proof (ZK-SNARK/STARK) to L1. The L1 instantly verifies the proof, guaranteeing correctness.
- Instant Finality: No withdrawal delays; state is proven, not disputed.
- Inherited Security: Validity is backed by Ethereum's consensus, not a separate fraud-proof game.
~10 min
Finality Time
L1 Secure
Security Model
05
The Problem: Proprietary Black Box AI
AI models are opaque, unverifiable, and controlled by corporations. Web3 applications (e.g., prediction markets, generative NFT platforms) cannot trust or audit the AI they rely on.
- Centralized Control: API providers can censor, manipulate, or change outputs.
- No Audit Trail: Impossible to prove an inference was run correctly on a specific model.
100%
Opacity
High
Censorship Risk
06
The Solution: zkML (e.g., Modulus, Giza, EZKL)
Generate zero-knowledge proofs of machine learning model inference. Anyone can verify the output came from a specific model and input without revealing the model weights.
- Verifiable AI: On-chain apps can trust the provenance and execution of AI.
- Model Monetization: Creators can sell model usage (proven via zk) without open-sourcing weights.
~1-10s
Proof Gen Time
Yes
Model Privacy
counter-argument
THE COST OF TRUST
Counter-Argument: "But It's Too Expensive!"
The cost of verifiable computation is not an expense but a fundamental investment in a trustless data economy.
The cost is the product. The expense of generating a zero-knowledge proof or a validity proof is the price of cryptographic trust. This replaces the operational overhead of auditing, legal compliance, and counterparty risk assessment in traditional systems.
Compare cost structures. A centralized API call is cheap but opaque. A verifiable compute proof is a marginally higher on-chain cost that provides a public, immutable audit trail. The total cost of trust in Web2 is hidden in enterprise contracts and liability insurance.
Scaling solves the equation. Innovations like zkEVMs (e.g., Polygon zkEVM, zkSync) and specialized coprocessors (e.g., RISC Zero) are driving proof generation costs down exponentially. The marginal cost of trust asymptotically approaches zero.
Evidence: The cost of a Groth16 zk-SNARK verification on Ethereum is ~200k gas. With EIP-4844 blobs, this is under $0.01. This cost is amortized across all users of the proven data, making per-query trust economically trivial.
risk-analysis
THE VULNERABILITIES
The Bear Case: Where This Foundation Cracks
Verifiable computation is the bedrock of trustless data, but its implementation is riddled with attack surfaces and economic misalignments.
01
The Prover Centralization Trap
The economic reality of proof generation creates a centralizing force. Specialized hardware (ASICs, GPUs) and economies of scale lead to a handful of dominant prover pools, recreating the miner/extractor centralization problem from L1s.
- Single points of failure emerge in systems like Polygon zkEVM or zkSync.
- Censorship risk if a major prover operator is compromised or coerced.
- Cost innovation stalls as the market consolidates, similar to Bitcoin mining.
>60%
Market Share Risk
$1M+
Hardware Barrier
02
The Oracle Problem Reborn
Verifiable computation only proves correct execution of a given input. If the input data is corrupt, the proof is worthless. This makes all ZK-rollups and oracle-dependent dApps vulnerable.
- Garbage in, gospel out: A manipulated price feed from Chainlink or Pyth produces a valid but fraudulent proof.
- Data availability crises like those plaguing Celestia-based rollouts become systemic.
- Bridges are weakest: Exploits on LayerZero or Wormhole often stem from flawed off-chain verification, not the cryptography.
$2B+
Bridge Exploits (2024)
1-of-N
Trust Assumption
03
Economic Abstraction Leaks
Users pay for proof generation, but the cost is abstracted away in gas fees or sequencer fees. This creates misaligned incentives where proof subsidization leads to unsustainable models and hidden centralization.
- Sequencer subsidies in StarkNet or Arbitrum Nova mask true cost, creating a rug-pull risk.
- Prover extractable value (PEV) emerges, where provers can reorder or censor transactions for MEV.
- Liveness failures occur if the subsidy ends and no one is willing to pay the real cost to prove the chain.
-99%
Subsidized Cost
T+?
Sustainability Clock
04
The Complexity Bomb
ZK-proof systems are astronomically complex. A single cryptographic bug or implementation flaw in Plonk, STARKs, or a custom circuit can invalidate the entire security model, with no clear path for recovery.
- Catastrophic failure mode: A broken proof system cannot be soft-forked like a consensus bug.
- Audit lag: The pace of innovation (e.g., Polygon's Type 1 prover, zkEVM wars) outpaces our ability to formally verify it.
- Upgrade risks: Moving from Groth16 to a newer system is a high-stakes, centralized migration.
10^6
Lines of Code
Months
Audit Cycle
future-outlook
THE VERIFIABLE DATA LAYER
Future Outlook: The Prover Network as a Primitive
Verifiable computation is the foundational primitive that will underpin Web3's data economy by commoditizing trust.
Verifiable computation commoditizes trust. Proof systems like zkSNARKs and zkSTARKs transform expensive consensus into cheap verification. This allows any network to outsource computation to the cheapest provider, creating a competitive proving market.
This market enables a data economy. Protocols like EigenDA and Celestia separate data availability from execution. Prover networks become the verification layer that validates this data's integrity, enabling scalable, trust-minimized applications.
Provers are the new validators. Just as Ethereum validators secure L1, specialized prover networks like RiscZero and Succinct will secure L2s and cross-chain states. Their hardware-optimized proving is the bottleneck for scaling.
Evidence: The cost to verify a zkEVM proof on Ethereum is ~500k gas, while generating it requires specialized hardware. This 1000x cost differential defines the prover network's economic moat.
takeaways
VERIFIABLE COMPUTATION
TL;DR: Takeaways for Builders and Investors
Trustless data processing is the bottleneck for scaling Web3 beyond simple token transfers. Here's where the real alpha is.
01
The Problem: The Oracle Dilemma
Smart contracts are blind. They rely on centralized oracles like Chainlink for critical data, creating a single point of failure and trust. This limits DeFi, insurance, and RWA protocols to a ~$50B TAM instead of the multi-trillion dollar real economy.
- Centralized Risk: Billions in TVL depend on a handful of data providers.
- Limited Scope: Complex off-chain computations (e.g., ML inference, game logic) are impossible.
~$50B
Current TAM
1-3
Critical Oracles
02
The Solution: ZK Coprocessors (e.g., RISC Zero, Axiom)
Move computation off-chain and prove it was done correctly on-chain. This turns any API or database into a trustless data source for smart contracts.
- Unlocks New Markets: Enables on-chain derivatives, credit scoring, and verifiable AI.
- Radical Cost Savings: Off-chain compute is ~1000x cheaper than EVM execution for complex tasks.
1000x
Cheaper Compute
Trustless
Data Source
03
The Investment Thesis: Infrastructure for the Data Economy
The next wave of Web3 growth isn't more L1s—it's verifiable data layers. Invest in stacks that prove state (e.g., Brevis, Lagrange), attest to compute (e.g., EigenLayer AVS), and enable private verification (e.g., Aztec).
- Protocols Become Data Consumers: The most valuable dApps will be the biggest buyers of verifiable compute.
- New Primitive Emerges: Verifiable compute will be as fundamental as the EVM or IPFS.
New Primitive
Market Layer
Data Consumers
Key Clients
04
The Builders' Playbook: Own the Proof Stack
Don't build another DEX. Build the verifiable order-matching engine for all DEXs. Vertical integration of proof generation (ZK/OP), data availability (Celestia, EigenDA), and settlement is the moat.
- Avoid the 'Oracle' Trap: Become the source of verifiable truth, not just a data relay.
- Monetize Proofs: The proof market itself is a multi-billion dollar opportunity, akin to Arbitrum's sequencer fees.
Vertical Stack
Builder Moat
$B+
Proof Market
ENQUIRY
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.
NDA Protected
Confidentiality24h Response
Time to ValueDirectly to Engineering Team
No Sales Fluff10+
Protocols Shipped
$20M+
TVL Overall