Free 30-min Web3 Consultation
Book Consultation
Smart Contract Security Audits
View Audit Services
Custom DeFi Protocol Development
Explore DeFi
Full-Stack Web3 dApp Development
View App Services
Free 30-min Web3 Consultation
Book Consultation
Smart Contract Security Audits
View Audit Services
Custom DeFi Protocol Development
Explore DeFi
Full-Stack Web3 dApp Development
View App Services
Free 30-min Web3 Consultation
Book Consultation
Smart Contract Security Audits
View Audit Services
Custom DeFi Protocol Development
Explore DeFi
Full-Stack Web3 dApp Development
View App Services
Free 30-min Web3 Consultation
Book Consultation
Smart Contract Security Audits
View Audit Services
Custom DeFi Protocol Development
Explore DeFi
Full-Stack Web3 dApp Development
View App Services
venture-capital-trends-in-web3
Blog

Why Recursive Proofs Are the Most Underrated VC Investment Thesis

Recursive proofs are the foundational primitive for infinite scaling and decentralized proving networks. This analysis argues VCs are missing the forest for the trees by underfunding this critical ZK infrastructure.

introduction
THE SCALING IMPERATIVE

Introduction

Recursive proofs are the only viable path to scaling blockchains to global throughput without sacrificing security or decentralization.

Recursive proofs enable infinite scaling by verifying other proofs, creating a hierarchy where a single on-chain proof validates millions of transactions. This compresses the computational load for the base layer, moving the bottleneck from consensus to prover hardware.

The investment thesis is underrated because most VCs focus on monolithic L1s or application-specific rollups. Recursive architecture is the foundational infrastructure that makes both viable, akin to betting on AWS instead of a single website.

Evidence: StarkWare's fractal scaling research demonstrates a path to 1M TPS on Ethereum, while projects like Lumoz (ex-ZKPool) and Nebra are building decentralized prover networks to commoditize this compute layer.

thesis-statement
THE META-ARCHITECTURE

The Core Thesis: Recursion is the Ultimate Abstraction

Recursive proofs are the fundamental primitive for building scalable, verifiable, and composable systems, representing the highest-order investment leverage in crypto infrastructure.

Recursion abstracts verification cost. A single proof verifies the correctness of an entire chain of computations, collapsing infinite state growth into a constant-sized cryptographic object. This is the mechanism behind zk-rollup scaling and projects like Scroll and zkSync.

Recursion enables trustless interoperability. It allows one chain to verify the state of another without trusted intermediaries, creating a verifiable compute fabric. This is the core thesis behind succinct cross-chain communication and protocols like Polygon zkEVM and Avail.

The investment leverage is exponential. Funding a recursive proof system like RISC Zero or SP1 funds every application built on it. It is the foundational layer for verifiable AI, gaming, and DeFi, making it the most capital-efficient thesis.

FEATURED SNIPPETS

The Recursive Proof Landscape: Who's Building What

A technical comparison of leading recursive proof systems, highlighting core capabilities, performance, and investment theses.

Core Metric / CapabilityRISC ZeroLasso & Jolt (a16z)Succinct SP1Nova (Espresso)

Proof System Architecture

zkVM (RISC-V)

zkVM (RISC-V) + Lookup Arguments

zkVM (RISC-V)

Folding Scheme (Nova-Scotia)

Primary Use Case

General-purpose zkVM, Bonsai Network

Ultra-efficient on-chain verification

General-purpose zkVM, Succinct Chain

Incremental Verifiable Computation (IVC)

Proving Time (for 1M constraints)

~60 seconds

< 10 seconds (est.)

~45 seconds

~15 seconds (per step)

Verification Gas Cost (Ethereum mainnet)

~450k gas

< 100k gas (target)

~400k gas

~200k gas (aggregated)

Recursion Native to Core Design

Parallel Proving Support

GPU Acceleration

Key Investment Thesis

First-mover, production-ready Bonsai network

Theoretical efficiency leap via lookup arguments

Performance-optimized, developer-friendly tooling

Elegant IVC for long-running stateful computations

deep-dive
THE INFRASTRUCTURE LAYER

The Deep Dive: From Aggregation to Sovereignty

Recursive proofs are the foundational technology enabling scalable, sovereign execution environments.

Recursive Proofs Enable Aggregation. A single proof can verify the validity of thousands of other proofs, collapsing computational overhead. This is the mechanism behind zkSync's Boojum and Starknet's SHARP, which batch proofs from many apps into one on-chain verification.

Aggregation Enables Sovereignty. This creates a new architectural paradigm: sovereign rollups. Chains like Eclipse and Sovereign SDK use recursive proofs to post their state transitions directly to a data availability layer, bypassing the smart contract constraints of L1 settlement.

Sovereignty Unlocks Vertical Integration. A sovereign chain controls its entire stack, from execution to social consensus. This allows for custom fee markets, native MEV capture, and protocol-specific governance that Ethereum L2s cannot implement.

Evidence: The Celestia ecosystem demonstrates this thesis. Over 50 sovereign rollups are building on its data availability, each using recursive proof systems like Risc Zero or SP1 for verification, creating a parallel, scalable execution universe.

risk-analysis
THE EXECUTION RISKS

The Bear Case: Why VCs Are Hesitant

Recursive proofs promise a new scaling paradigm, but the path is littered with technical and market risks that give investors pause.

01

The Hardware Bottleneck

Recursive proving is computationally intensive, demanding specialized hardware like GPUs or FPGAs. This creates a centralization risk and a high operational cost barrier.

  • Proving times for complex recursion can still be ~10-30 seconds, negating real-time UX benefits.
  • Capital expenditure for a competitive proving cluster can exceed $1M, creating a moat only for well-funded players like Espresso Systems or Ingonyama.
~30s
Prove Time
$1M+
Capex
02

The Tooling Desert

Developer adoption is crippled by a lack of mature, high-level frameworks. Building with recursion today is like writing assembly code for ZK.

  • Missing standardized libraries for common operations (e.g., signature aggregation, Merkle proofs) force teams to reinvent the wheel.
  • The ecosystem lacks the equivalent of a Hardhat or Foundry for recursive ZK, slowing iteration to a crawl.
<10
Active Teams
6-12mo
Dev Lag
03

The 'So What?' Problem

Beyond theoretical elegance, there's a scarcity of killer applications that require recursion. Most dApps today are satisfied with simpler, proven scaling.

  • Projects like zkSync and Starknet achieve massive scale with single, non-recursive proofs.
  • Until an app demonstrates a 10x UX improvement (e.g., instant cross-chain composability via LayerZero), the market will remain skeptical.
0
Killer Apps
~2-5yrs
Timeline
04

The Fragmented Proof System War

The landscape is split between STARKs (StarkWare), SNARKs (zkSync), and hybrid models. Recursion implementations are not interoperable, risking protocol lock-in.

  • A recursive proof built for Plonky2 cannot be verified in a Halo2 circuit, fracturing liquidity and developer mindshare.
  • This mirrors the early L1 wars, where the winner (EVM) won through network effects, not pure tech.
3+
Major Systems
High
Lock-in Risk
05

The Verifier Centralization Trap

The final recursive proof must be verified on-chain by a single, expensive verifier contract. This creates a central point of failure and cost.

  • Ethereum L1 verification gas costs can still be >500k gas, making frequent updates prohibitive.
  • It recreates the very problem recursion aims to solve: pushing the bottleneck to a single, expensive resource.
>500k
Gas Cost
1
Final Verifier
06

The Economic Model Is Unproven

There is no clear playbook for monetizing recursive proof infrastructure. Will it be a protocol fee, a sequencing auction, or a data availability rental?

  • Provers face volatile revenue based on chain congestion, unlike the steady yield of Lido or Aave.
  • The market may converge on a commoditized, low-margin business, undermining the venture-scale returns VCs require.
$0
Clear Model
Low
Margin Outlook
investment-thesis
THE CAPITAL STACK

The Investment Implication: Fund the Primitives

Recursive proofs are the foundational compute layer for the next generation of high-throughput applications, making them a non-negotiable infrastructure bet.

Invest in the compute layer. Recursive proofs are a zero-to-one primitive for scalable computation, not just a faster prover. This creates a new capital stack where applications like Hyperliquid and dYdX build on shared proving infrastructure, mirroring how AWS enabled internet startups.

The moat is mathematical, not social. Unlike L1s competing for developer mindshare, a performant recursive proving system becomes a commoditized utility. The winner captures value from all applications requiring verifiable compute, from ZK rollups to on-chain AI inference.

Evidence: Jolt's benchmarks show 20k proofs/second on a single GPU. This throughput enables real-time settlement for perpetual DEXs and on-chain gaming worlds, moving beyond the batch-processing model of today's rollups.

takeaways
WHY IT'S THE MOST UNDERRATED VC INVESTMENT THESIS

TL;DR: The Recursive Proof Thesis

Recursive proofs are the cryptographic engine for scaling blockchains, enabling verifiable computation that compresses exponentially. This isn't just about rollups; it's about re-architecting the entire stack.

01

The Problem: The Verifier Bottleneck

Every L2 rollup (Arbitrum, Optimism, zkSync) must post a proof to L1. With hundreds of rollups, the L1 becomes a congested, expensive verifier of proofs, not transactions.\n- Cost: Proving cost scales with L1 gas, not L2 activity.\n- Throughput: L1 block space limits total system-wide proofs per second.

~15 sec
L1 Finality Lag
$1M+
Daily Proving Cost
02

The Solution: Proofs That Prove Proofs

Recursion allows a single proof to verify the correctness of other proofs, aggregating them. This creates a hierarchy where only a tiny, final proof hits L1.\n- Exponential Compression: A single L1 proof can represent thousands of L2 blocks.\n- Cost Amortization: Proving cost is distributed across all aggregated transactions, driving marginal cost toward zero.

1000x
Proof Compression
< $0.001
Target Cost/Tx
03

The Meta-Protocol Play: EigenLayer & AltDA

Recursive proofs enable decentralized proving markets and shared security layers. EigenLayer restakers can secure proof verification networks, creating a new cryptoeconomic primitive.\n- Shared Security: A decentralized network of provers replaces centralized sequencer/prover oligopolies.\n- AltDA: Enables scalable, secure data availability layers like Celestia and EigenDA to be efficiently verified.

$15B+
Restaked TVL
10-100x
Prover Decentralization
04

The Endgame: Sovereign Rollups & Interop

Recursion is the key to sovereign rollups (fueled by Celestia) and seamless cross-chain interoperability. A recursive proof can verify state transitions across multiple chains in one shot.\n- Sovereignty: Chains maintain execution independence but inherit L1 security via a tiny proof.\n- Interop: Projects like Polygon zkEVM, zkSync, and Starknet use recursion for native, trustless bridging.

~500ms
Cross-Chain State Finality
-99%
Bridge Trust Assumptions
05

The Hardware Moats: ASICs & Cloud

Recursive proving is computationally intensive, creating a race for specialized hardware (ASICs, GPUs, FPGAs) and optimized cloud pipelines. This is a physical infrastructure investment thesis.\n- Performance: ASICs can accelerate recursive SNARKs by 100-1000x vs. general CPUs.\n- Centralization Risk: The proving market may consolidate around a few hardware-optimized players like Ulvetanna.

$100M+
ASIC Capex
10x
Proving Speedup
06

The Application Layer: Prover-as-a-Service

Every dApp requiring complex, verifiable off-chain computation (AI, games, order-book DEXs) becomes a customer for recursive proof networks. This creates a B2B SaaS model on-chain.\n- New Markets: On-chain AI inference, verifiable gaming physics, and private MEV auctions.\n- Key Players: RiscZero, Succinct, and Espresso Systems are building this infrastructure layer.

$50B+
TAM for Verifiable Compute
100k TPS
App-Specific Chain Capacity
ENQUIRY

Get In Touch
today.

Our experts will offer a free quote and a 30min call to discuss your project.

NDA Protected
24h Response
Directly to Engineering Team
10+
Protocols Shipped
$20M+
TVL Overall
NDA Protected Directly to Engineering Team
Why Recursive Proofs Are the Most Underrated VC Thesis | ChainScore Blog