The Blockchain Computation Problem
Blockchains were supposed to be “world computers.” After years of scaling innovation, you’d expect them to be fast, efficient computing machines.
They’re not.
A blockchain can’t run faster than a single server. Worse, it’s exponentially more expensive. Here’s why: when a transaction executes on Ethereum, it gets re-executed over 800,000 times. Not replicated. Re-executed. Every single validator independently runs the exact same calculation, reads the same state, and arrives at the same result.
This redundancy is what makes blockchains trustless. No single party controls the computation. Everyone verifies independently. This is blockchain’s superpower and its fundamental limitation.
The cost becomes prohibitive not because individual calculations are complex, but because 800,000 validators must each perform them independently. Ethereum’s block capacity stays artificially low because validators need reasonable hardware to keep up with re-execution demands. Every increase in block size means more computation for every validator.
The network can’t grow without either centralizing validation or sacrificing throughput. This is the computational bottleneck that has constrained blockchain capability since the beginning.
What This Actually Means
Take a simple example that should be trivial: VIP trading discounts based on volume.
A decentralized exchange wants to offer fee discounts to high-volume traders. Check your last 30 days of trading activity, calculate total volume, apply discount tier. On Coinbase or Binance, this is a basic benefit.
On-chain? Impossible.
Calculating one user’s trading history across thousands of transactions would require every validator to process those thousands of past transactions. The gas cost would be higher than any fee discount you could offer. It would take hours and cost tens of thousands of dollars to compute what Coinbase does in milliseconds for free.
This is why DeFi protocols offer the same experience to everyone regardless of loyalty, usage patterns, or contribution history. Features that are standard on centralized platforms remain out of reach not because developers don’t want them, but because the computational model makes them impossible. This single constraint ripples across everything blockchains try to do. It’s why scaling remains an unsolved problem. It’s why sophisticated applications require workarounds and compromises. It’s the fundamental obstacle limiting what decentralized systems can achieve.
The Solution: Verifiable Computing
Brevis eliminates this constraint with a different approach: verifiable computing.
Instead of every validator re-executing computation, one prover executes it off-chain and generates a mathematical proof that the computation was done correctly. The blockchain verifies this tiny proof in milliseconds instead of re-executing the entire calculation.
Verification takes a fraction of the resources that re-execution requires. The blockchain doesn’t need to trust the prover because the math guarantees correctness. Validators can confirm a transaction executed properly without performing the computation themselves.
This “compute off-chain, verify on-chain” paradigm gives blockchain applications unlimited computational freedom without sacrificing the trustlessness that makes decentralization valuable.
What We Built
Brevis developed two complementary products that eliminate blockchain’s computational constraints in various ways.
Pico zkVM: The Universal Verifiable Computing Engine
Pico is a zero-knowledge virtual machine that makes any program verifiable.
It works like this: developers write a program in Rust for any computation they need (calculating numbers, processing data, running algorithms, simulating physics, anything). Pico executes that program off-chain, produces the result, and generates a cryptographic proof that the computation ran correctly. Smart contracts can verify the tiny proof on-chain instead of re-executing the entire program.
Any logic you can code in Rust, Pico can prove.
Other zkVMs already exist, but they face a difficult challenge: build something general-purpose that handles any computation but proves slowly, or optimize for speed with specialized circuits but sacrifice flexibility. You get either versatility or performance, not both.
Pico’s innovation is modularity. The architecture combines a general-purpose core (the “glue”) with specialized coprocessors. The core can execute any program. When specific operations come up (processing blockchain data, verifying signatures, running ML inference), Pico routes those to optimized coprocessors that prove 10x to 80x faster.
View live on Ethproofs,
This modular architecture enabled us to achieve something the entire zkVM industry has been racing toward.
Scaling Ethereum: Pico Prism
We also pushed Pico’s architecture further with Pico Prism, a multi-GPU cluster system designed specifically for Ethereum block proving.
The context: Ethereum’s scaling roadmap depends on real-time block proving. Instead of every validator re-executing transactions, one prover generates a proof and everyone else verifies it. The Foundation set the target: prove 99% of blocks under 10 seconds with hardware under $100K.
For two years, teams competed to hit this benchmark. The previous best (SP1 Hypercube) achieved only 40.9% real-time proving on 36M gas blocks using $256K hardware and 160 GPUs.
Pico Prism achieved 96.8% real-time proving (sub-10 secondhttps://x.com/ethereum/status/1978497335115051056s) and 99.6% coverage (sub-12 seconds) on current 45M gas Ethereum blocks using $128K hardware with 64 GPUs. The achievement earned praise from Vitalik Buterin, Justin Drake, and the Ethereum Foundation.
Comparison
| Metric | SP1 Hypercube | Pico Prism | Improvement |
|---|---|---|---|
| RTP (<10s) coverage (36M gas limit) | 40.9% | 98.9% | 2.4x higher coverage |
| RTP (<10s) coverage (45M gas limit) | N/A | 96.8% | First to achieve |
| GPU cost (MSRP-based) | $256K | $128K | 50% Reduction |
| Average proving time | 10.3sec | 6.04sec | 71% Faster |
| GPU requirements | 160x 4090s | 64x 5090s | Fewer GPUs |
Pico Prism is now the fastest zkVM in production, just 2.2% away from the Foundation’s 99% target. We’re already implementing straightforward optimizations that will close that gap completely in the coming months.
ZK Data Coprocessor: Specialized Blockchain Intelligence
The coprocessor architecture that powers Pico’s performance gains also exists as a standalone product specialized for blockchain data.
Remember the VIP trading discount problem from earlier? Smart contracts are blind. They can’t access historical data without prohibitive costs. A DEX that wants to offer volume-based pricing would spend more computing your trading history than any discount could save.
The ZK Data Coprocessor solves this. We retrieve and analyze blockchain data off-chain where it’s fast and cheap. Then we provide smart contracts with both the result and cryptographic proof that the data exists on-chain and the computation is correct. The blockchain verifies a tiny proof instead of re-executing thousands of transactions.
Volume-based discounts are just one example. The ZK Data Coprocessor enables loyalty programs, time-weighted rewards, sophisticated risk analysis, cross-chain data verification, and countless features that were impossible for DeFi not long ago. What used to require centralized servers or cost thousands in gas fees now runs trustlessly for pennies.
Explore ZK Data Coprocessor documentation →
ProverNet: Opening Our Infrastructure to the Ecosystem
Building Pico and the ZK Data Coprocessor taught us something that only becomes visible at scale.
After generating hundreds of millions of proofs across diverse protocols, we kept running into the same pattern: ZK workloads are wildly different from each other, and no single proving setup handles them all well.
When PancakeSwap checks whether a trader qualifies for VIP pricing, that proof needs to generate in 2-3 seconds. It scans 30 days of history for a single address. Latency is everything. When Linea distributes rewards across their entire ecosystem, the calculation processes hundreds of thousands of addresses over multi-hour windows. Throughput matters more than speed. When Pico Prism proves Ethereum blocks in real-time, it needs high-performance GPUs with fast memory access. Batch aggregation tasks for reward distributions run better on CPU clusters optimized for parallel processing.
These workloads require different hardware, different proof systems, different optimizations. A configuration tuned for sub-second DEX hooks underperforms on multi-hour batch jobs. Infrastructure optimized for STARK-heavy operations leaves performance on the table for SNARK-focused workloads.
The ZK ecosystem reflects this reality. Specialized teams have built proving infrastructure optimized for specific workload types. The capability exists somewhere for almost any problem. What’s missing is the coordination layer that connects applications to the right provers for their specific needs.
ProverNet is that layer.
Rather than scaling all proving capacity in-house, we built a marketplace where specialized provers contribute what they do best. Applications submit proof requests with their exact requirements: latency targets, cost constraints, proof size limits, security parameters. Provers with the right setup compete for jobs they’re built to handle. The TODA (Truthful Online Double Auction) mechanism matches them, treating different proof types as distinct categories rather than assuming all proving work is interchangeable.
The marketplace runs on Brevis Chain, a dedicated rollup for auction coordination. Provers stake BREV tokens to participate. If they accept a job and miss the deadline, their stake gets slashed. Applications don’t trust that provers will deliver. The mechanism enforces it.
BREV serves three functions: payment for proving fees, staking collateral that provers lock to receive work, and governance over protocol parameters.
Current status: ProverNet mainnet beta is live. Full BREV staking and token payments activate at mainnet launch.
[Read ProverNet Whitepaper] [Blog]
Use Cases
Brevis stands out not just for the ZK technology we’ve built, but for the live applications already running on it. Our infrastructure powers smart wallets with verifiable reputation, DEXes with volume-based discounts, yield optimizers with fair distributions, stablecoin protocols with continuous incentives, blockchain growth programs, liquid restaking rewards, lending protocol calculations, perpetual exchange loyalty systems, and AI personalization. Everything once considered impossible now runs trustlessly at scale.
Intelligent DeFi
Personalized fees, rewards, and user experiences based on historical behavior and market conditions. DEXes, yield aggregators, and lending protocols offer volume discounts, loyalty programs, and dynamic configurations.
PancakeSwap | Uniswap | MetaMask | Euler Finance | QuickSwap | THENA | Algebra Labs | Beefy | BeraBorrow | Aave | Kwenta | JOJO Exchange | Bedrock | Mellow | Lista | KoalaSwap |
Turtle
RWA and Stable Token Growth
Stablecoin and real-world asset protocols implement continuous incentivization with transparent distribution. Rewards based on verifiable on-chain activity and participation history.
OpenEden |Usual Money | MetaMask USD | YiledNest
DEX with Dark Pools
Order books and matching engines operate off-chain with L1-level security. ZK proofs enable private trading while maintaining trustless verification.
100X Faster L1s
Blockchain consensus shifts from network-wide computation to single-node proving with distributed verification. Real-time proving enables 100x scalability improvements.
Blockchain Bootstrap
New blockchains launch sophisticated growth programs with verifiable incentive distribution. Ecosystem-wide liquidity and user acquisition through transparent ZK-powered mechanisms.
Linea | TAC | Units Network
Cross-chain Interoperability
Cross-chain restaking and instant interoperability between rollups and L1 blockchains. ZK proofs enable trustless bridging and shared security.
Verifiable AI
AI applications with privacy-preserving personalization and provable model outputs. Data-driven experiences without exposing user data or compromising computation integrity.
Kaito | Trusta | Kite AI | Pieverse | Vana | UnifAI
Privacy
Privacy-preserving computation and confidential data processing with ZK proofs. Enable sensitive operations while maintaining data confidentiality and verification integrity.
Security
ZK-verified security assessments and risk analysis for DeFi protocols. Trustless security data delivery and verifiable compliance checking across blockchain ecosystems.
Prediction Markets
Prediction markets settle with cryptographic certainty using ZK-verified real-world data. Market outcomes resolved through provable data authenticity and trustless computation, eliminating human validators and subjective oracle consensus.
What Makes Brevis Different
Production Scale That Proves It Works
Most ZK projects publish research papers and promise future performance. Brevis runs production systems processing real transactions for real users with real money.
The numbers:
- 288M+ cryptographic proofs generated
- 205K+ unique users across ecosystems
- ~19,000 daily active users
- $232M+ in rewards distributed with mathematical guarantees
- $2.5B in TVL growth enabled
- 40+ major protocol partnerships live in production
- 6 blockchains supported
This is production infrastructure trusted by major protocols and used by thousands of people daily.
Technical Leadership That’s Measurable
Brevis delivers measurable superiority today:
Pico Prism Achievement:
- Fastest zkVM to with 96.8% real-time proving (sub-10s) for current Ethereum blocks
- 50% hardware cost reduction vs. nearest competitor ($128K vs $256K)
- 3.4x better overall performance efficiency combining speed and cost
- Only production-ready technology making Ethereum’s ZK scaling vision economically viable
ZK Data Coprocessor Performance:
- Up to 80x performance gains for blockchain data operations
- Powers the largest trustless reward systems in production ($300M+ annually)
- Processes millions of proofs daily for major protocols
Frontrunners for Ethereum L1 Integration
The Ethereum Foundation’s July 2025 roadmap outlined the path to ZK-based L1 validation. Brevis achieved what the entire industry has been racing toward.
We’re positioned as leading candidates for Ethereum’s L1 zkEVM integration. When the network transitions to proof-based validation as outlined in the Foundation’s scaling roadmap, Brevis infrastructure is ready to power that transformation.
Our benchmarks are public, reproducible, and recognized by the Ethereum Foundation as critical progress toward their scaling goals.
Marketplace Infrastructure for ZK Proving
Brevis CEO Miachel has a prediction: in ten years, 99% of computation for blockchain applications will happen off-chain, verified by ZK proofs. If that’s where the industry is heading, coordination of proving capacity becomes foundational infrastructure.
Most ZK projects compete as provers. ProverNet positions us as the marketplace where proving demand meets specialized capacity. Applications submit proof requests, provers compete to fulfill them, and the TODA auction matches workloads to the right infrastructure. We participate as provers using our own Pico technology, but the larger play is coordinating the ecosystem’s proving resources as that future arrives.
Learn More:
- Website
- Pico Prism Achievements
- Pico Documentation
- ZK Data Coprocessor Documentation
- ProverNet Whitepaper
- ProverNet Documentation
- $BREV
- Ecosystem
- Blog
Join the Community:
Brevis Network© 2023 