Author: 0xjacobzhao

The trusted computing paradigm of "off-chain computation + on-chain verification" has become a universal computing model for blockchain systems. It allows blockchain applications to achieve virtually unlimited computational freedom while maintaining the security of decentralization and trustlessness. Zero-knowledge proofs (ZKPs) are a core pillar of this paradigm, with applications primarily focused on three fundamental areas: scalability, privacy, and interoperability and data integrity. Scalability was the first application scenario for ZK technology. By moving transaction execution off-chain and verifying the results on-chain with short proofs, it achieves high transaction throughput and low-cost trusted scalability.

The evolution of ZK trusted computing can be summarized as L2 zkRollup → zkVM → zkCoprocessor → L1 zkEVM. Early L2 zkRollup migrated execution to Layer 2 and submitted validity proofs on Layer 1, achieving high throughput and low-cost scalability with minimal modifications. zkVM subsequently expanded into a general-purpose verifiable computation layer, supporting cross-chain verification, AI reasoning, and cryptographic computation (representative projects: Risc Zero, Succinct, Brevis Pico). The zkCoprocessor developed in parallel as a scenario-based verification module, providing plug-and-play computation and proof services for DeFi, Reliable Web Apps (RWA), risk management, and more (representative projects: Brevis, Axiom). In 2025, the zkEVM concept was extended to Layer 1 Realtime Proving (RTP), building verifiable circuits at the EVM instruction level. This enabled zero-knowledge proofs to be directly integrated into the Ethereum mainnet execution and verification process, becoming a natively verifiable execution mechanism. This context reflects the technological leap of blockchain from "scalability" to "verifiability", opening a new stage of trusted computing.

1. Ethereum zkEVM Scaling Path: From L2 Rollup to L1 Real-Time Proof

Ethereum’s zkEVM scaling path goes through two phases:

• Phase 1 (2022–2024): L2 zkRollup moves execution to Layer 2, submitting validity proofs on Layer 1; significantly reducing costs and improving throughput, but introducing liquidity and state fragmentation, while L1 is still subject to N-of-N re-execution.
• Phase 2 (2025–): L1 Realtime Proving (RTP) replaces heavy execution with "1-of-N proof + lightweight verification across the entire network", improving throughput without sacrificing decentralization. It is still evolving and developing.

L2 zkRollup Phase: Balancing Compatibility and Scaling Performance

In 2022, as the Layer 2 ecosystem flourished, Ethereum founder Vitalik Buterin proposed a four-category classification of ZK-EVM (Types 1–4), systematically revealing the structural tradeoffs between compatibility and performance. This framework established a clear coordinate for the subsequent zkRollup technology roadmap:

• Type 1 is fully equivalent: consistent with Ethereum bytecode, with the lowest migration cost and slowest proof. Taiko.
• Type 2 is fully compatible: minimal underlying optimizations, and offers the best compatibility. Scroll, Linea.
• Type 2.5 quasi-compatible: minor changes (gas/precompilation, etc.) for performance. Polygon zkEVM, Kakarot.
• Type 3 partial compatibility: This involves more significant changes and can run most applications, but it is difficult to fully reuse the L1 infrastructure. zkSync Era.
• Type 4 language level: Abandoning bytecode compatibility, directly compiling from high-level languages into circuits, with optimal performance but requiring ecosystem reconstruction (representatives: Starknet/Cairo).

The L2 zkRollup model has matured. By migrating execution to Layer 2 and submitting validity proofs on Layer 1, it leverages the Ethereum ecosystem and toolchain with minimal modifications, becoming a mainstream solution for scaling and reducing fees. Its proofs are based on L2 blocks and state transitions, while settlement and security remain anchored on Layer 1. This architecture significantly improves throughput and efficiency while maintaining high developer compatibility. However, it also introduces liquidity and state fragmentation, and L1 is still limited by the N-of-N re-execution bottleneck.

L1 zkEVM: Real-time Proof Reshapes Ethereum’s Light Verification Logic

In July 2025, the Ethereum Foundation published the article "Shipping an L1 zkEVM #1: Realtime Proving," formally proposing the L1 zkEVM approach. L1 zkEVM upgrades Ethereum from N-of-N re-execution to 1-of-N proofs with fast network-wide verification: a small number of provers generate short proofs for entire EVM state transitions, while all validators perform constant-time verification. This solution achieves L1-level real-time proofing without sacrificing decentralization, securely increasing mainnet gas limits and throughput, and significantly lowering the node hardware barrier. The implementation plan is to replace traditional execution clients with zk clients, initially running them in parallel. Once performance, security, and incentive mechanisms mature, it will gradually become the new norm at the protocol level.

• N of N old paradigm: All validators repeatedly execute the entire block of transactions to verify, which is secure but has limited throughput and high peak fees.
• 1 of N new paradigm: A small number of provers execute the entire block and produce short proofs; the entire network only verifies in constant time. Verification costs are much lower than re-execution, allowing for safe increases in L1 gas limits and reduced hardware requirements.

Three main lines of the L1 zkEVM roadmap

• Realtime Proving: Complete full block proof in 12-second slots, compressing latency through parallelization and hardware acceleration.
• Client and protocol integration: standardized proof verification interface, first optional and then default;
• Incentives and Security: Establish a Prover market and fee model to enhance censorship resistance and network activity.

Ethereum's L1 Real-Time Proofs (RTP) uses zkVM to re-execute entire transactions off-chain and generate cryptographic proofs. This allows validators to verify a small proof in under 10 seconds without recalculation, effectively replacing execution with verification. This significantly improves Ethereum's scalability and trustless verification efficiency. According to the Ethereum Foundation's official zkEVM Tracker page, the main teams currently involved in the L1 zkEVM real-time proofs project include SP1 Turbo (Succinct Labs), Pico (Brevis), Risc Zero, ZisK, Airbender (zkSync), OpenVM (Axiom), and Jolt (a16z).

Beyond Ethereum: Universal zkVM and zkCoprocessor

Outside the Ethereum ecosystem, zero-knowledge proof (ZKP) technology has also extended to the broader field of general verifiable computing, forming two technical systems with zkVM and zkCoprocessor as the core.

zkVM: A universal verifiable computation layer

A verifiable execution engine for arbitrary programs, targeting common instruction set architectures including RISC-V, MIPS, and WASM. Developers can compile their business logic into zkVM, which is executed off-chain by a prover and generates zero-knowledge proofs (ZKPs) verifiable on-chain. This can be used for block attestation on Ethereum L1, as well as cross-chain verification, AI reasoning, cryptographic computation, and complex algorithms. While its advantages lie in its versatility and wide adaptability, it also comes with complex circuitry and high proof costs, requiring multi-GPU parallelism and strong engineering optimization. Representative projects include Risc Zero, Succinct SP1, and Brevis Pico/Prism.

zkCoprocessor: A scenario-based verifiable module

This platform provides plug-and-play computation and proof services tailored to specific business scenarios. The platform pre-configures data access and circuit logic (such as historical on-chain data reading, TVL, revenue settlement, and identity verification). Applications can access computation results and proofs through SDK/API calls for on-chain consumption. This model offers fast adoption, excellent performance, and low cost, but its versatility is limited. Typical projects include Brevis zkCoprocessor and Axiom.

Overall, both zkVM and zkCoprocessor adhere to the trusted computing paradigm of "off-chain computation + on-chain verification," verifying off-chain results on-chain through zero-knowledge proofs. Their economic logic is based on the premise that the cost of direct on-chain execution is significantly higher than the combined cost of generating off-chain proofs and verifying them on-chain.

The key differences between the two in terms of versatility and engineering complexity are:

• zkVM is a general-purpose computing infrastructure suitable for complex, cross-domain, or AI scenarios, with the highest flexibility;
• zkCoprocessor is a modular verification service that provides a low-cost, directly callable verification interface for high-frequency reusable scenarios (DeFi, RWA, risk control, etc.).

In terms of business models, the differences between zkVM and zkCoprocessor are:

• zkVM adopts the Proving-as-a-Service model, with a per-proof (ZKP) billing policy. It is primarily targeted at infrastructure customers such as L2 Rollup and is characterized by large contract sizes, long cycles, and stable gross profit margins.
• zkCoprocessor is mainly based on Proof API-as-a-Service, and is billed by task through API calls or SDK integration. It is closer to the SaaS model and is aimed at application layer protocols such as DeFi, with fast integration and strong scalability.

In general, zkVM is the underlying engine for verifiable computing, and zkCoprocessor is the application-layer verification module: the former builds a technological moat, while the latter drives commercialization, together forming a universal trusted computing network.

3. Brevis’ Product Portfolio and Technology Path

Starting with Ethereum's L1 realtime proofs, ZK technology is gradually moving towards an era of verifiable computing centered on the universal zkVM and zkCoprocessor architecture. The Brevis Network is a fusion of zkVM and zkCoprocessor, building a universal verifiable computing infrastructure with zero-knowledge computing at its core, combining high performance and programmability—the Infinite Compute Layer for Everything.

3.1 Pico zkVM: A Modular Proof-of-Stake Architecture for Universal Verifiable Computation

In 2024, Vitalik proposed the "general execution layer + coprocessor acceleration layer" (glue & coprocessor) architecture in "Glue and Coprocessor Architectures." Complex computations can be split into general business logic and structured intensive computations—the former pursuing flexibility (such as EVM, Python, and RISC-V), while the latter pursues efficiency (such as GPUs, ASICs, and hash modules). This architecture is becoming a common trend in blockchain, AI, and cryptographic computing: the EVM accelerates through precompile, AI leverages GPU parallelization, and ZK proofs combine general VMs with dedicated circuits. The key to the future is to have the "glue layer" optimize security and development experience, while the "coprocessor layer" focuses on efficient execution, achieving a balance between performance, security, and openness.

Pico zkVM, developed by Brevis, is a representative implementation of this concept. Through its "general-purpose zkVM + coprocessor acceleration" architecture, it combines flexible programmability with the high-performance computing of dedicated circuits. Its modular design supports multiple proof backends (KoalaBear, BabyBear, and Mersenne31), and allows for the free combination of execution, recursion, and compression components to form a ProverChain.

Pico's modular architecture not only allows for the free reconfiguration of core components but also enables the introduction of new proof backends and application-level coprocessors (such as on-chain data, zkML, and cross-chain verification), achieving continuous scalability. Developers can directly use the Rust toolchain to write business logic and automatically generate cryptographic proofs without any prior knowledge, significantly lowering the development barrier.

Compared with the relatively monolithic RISC-V zkVM architecture of Succinct SP1 and the general RISC-V execution model of RISC Zero R0VM, Pico achieves decoupling and expansion of the execution, recursion and compression stages through Modular zkVM + Coprocessor System, supports multi-backend switching and coprocessor integration, and forms a differentiated advantage in performance and scalability.

3.2 Pico Prism: Performance Breakthrough for Multi-GPU Clusters

Pico Prism represents a significant breakthrough for Brevis in multi-server GPU architecture, setting a new record within the Ethereum Foundation's Real-Time Proving (RTP) framework. On a 64x5090 GPU cluster, it achieved an average proof time of 6.9 seconds and 96.8% RTP coverage, ranking it among the best performing zkVMs in its class. This system, optimized at the architectural, engineering, hardware, and system levels, marks the transition of zkVM from research prototype to production-grade infrastructure.

• Architecture Design: Traditional zkVMs (such as SP1 and R0VM) primarily rely on single-machine GPU optimization. Pico Prism is the first to implement multi-server, multi-GPU cluster-level zk proving. Through multi-threading and sharding scheduling, zk proving is expanded into a distributed computing system, significantly improving parallelism and scalability.
• Engineering implementation: Build a multi-stage asynchronous pipeline (Execution/Recursion/Compression) and a cross-layer data reuse mechanism (proof chunk caching and embedding reuse), and support multi-backend switching (KoalaBear, BabyBear, M31), significantly improving throughput efficiency.
• Hardware strategy: Under the configuration of 64×RTX 5090 GPU (about $128K), Pico Prism achieved an average proof time of 6.0–6.9 seconds and 96.8% RTP coverage, with a performance/cost ratio improved by about 3.4 times, which is better than SP1 Hypercube (160×4090 GPU, 10.3 seconds).
• System Evolution: As the first zkVM to meet the Ethereum Foundation's RTP indicators (>96% sub-10s, <$100K cost), Pico Prism marks the zk proof system's transition from a research prototype to mainnet-level production infrastructure, providing a more economical zero-knowledge computing solution for scenarios such as Rollup, DeFi, AI and cross-chain verification.

3.3 ZK Data Coprocessor: Blockchain Data Intelligent Zero-Knowledge Coprocessor Layer

Smart contracts inherently lack memory—they can't access historical data, identify long-term behavior, or conduct cross-chain analysis. Brevis' high-performance zero-knowledge coprocessor (ZK Coprocessor) provides cross-chain historical data access and trusted computing capabilities for smart contracts. It verifies and computes the entire blockchain's historical state, transactions, and events, enabling applications in data-driven DeFi, proactive liquidity management, user incentives, and cross-chain identity verification.

Brevis's workflow consists of three steps:

1. Data access: Smart contracts can read historical data trustlessly through APIs;
2. Computation execution: Developers use the SDK to define business logic, which is then calculated and generated by the Brevis chain.
3. Result verification: The proof result is sent back to the chain, verified by the contract and the subsequent logic is called.

Brevis supports both Pure-ZK and CoChain (OP) models: the former achieves complete trust minimization, but at a higher cost; the latter allows verifiable computing at a lower cost through PoS verification and ZK challenge mechanism. The validator stakes on Ethereum, and if the result is proven by ZK that the challenge is successful, it will be fined, thus achieving a balance between security and efficiency. Through the architectural fusion of ZK + PoS + SDK, Brevis strikes a balance between security and efficiency and builds a scalable trusted data computing layer. Currently, Brevis has served protocols such as PancakeSwap, Euler, Usual, Linea, etc. All zkCoprocessor collaborations are based on the Pure-ZK model, providing trusted data support for DeFi, reward distribution and on-chain identity systems, so that smart contracts truly have "memory and intelligence."

3.4 Incentra: ZK-based “Verifiable Incentive Distribution Layer”

Incentra is a trusted incentive distribution platform powered by the Brevis zkCoprocessor, providing a secure, transparent, and verifiable reward calculation and distribution mechanism for DeFi protocols. It directly verifies incentive results on-chain through zero-knowledge proofs, enabling trustless, low-cost, and cross-chain incentive execution. The system calculates and verifies rewards within ZK circuits, ensuring that any user can independently verify the results. It also supports cross-chain operations and access control, enabling compliant, secure, and automated incentive distribution.

Incentra mainly supports three types of incentive models:

• Token Holding: Calculates long-term holding rewards based on ERC-20 Time Weighted Balance (TWA);
• Concentrated Liquidity: Distributes liquidity rewards based on the AMM DEX fee ratio, compatible with ALM protocols such as Gamma and Beefy;
• Lend & Borrow: Calculates lending rewards based on the average of balance and debt.

The system has been applied to projects such as PancakeSwap, Euler, Usual, Linea, etc., realizing a full-chain trusted closed loop from incentive calculation to distribution, and providing a ZK-level verifiable incentive infrastructure for DeFi protocols.

3.5 Overview of Brevis Product Technology Stack

4. Brevis zkVM Technical Indicators and Performance Breakthroughs

The L1 zkEVM Realtime Proving (RTP) standard proposed by the Ethereum Foundation (EF) has become the industry consensus and entry threshold for zkVM to enter the Ethereum mainnet verification process. Its core evaluation metrics include:

• Latency requirement: P99 ≤ 10 seconds (matching Ethereum's 12-second block cycle);
• Hardware constraints: CAPEX ≤ $100K, power consumption ≤ 10kW (suitable for home use or small computer rooms);
• Security level: ≥128-bit (≥100-bit during transition period);
• Proof size: ≤300 KiB;
• System requirements: Must not rely on trusted settings, and the core code must be completely open source.

In October 2025, Brevis released the report "Pico Prism — 99.6% Real-Time Proving for 45M Gas Ethereum Blocks on Consumer Hardware", announcing that its Pico Prism became the first zkVM to fully pass the Ethereum Foundation (EF) real-time block proof (RTP) standard.

On a 64x RTX 5090 GPU configuration (approximately $128,000), Pico Prism achieved an average latency of 6.9 seconds, 96.8% less than 10 seconds, and 99.6% less than 12 seconds in a 45M gas block. This performance significantly outperforms the Succinct SP1 Hypercube (36M gas, average latency of 10.3 seconds, 40.9% less than 10 seconds). With a 71% reduction in latency and halving the hardware cost, the overall performance/cost efficiency improved by approximately 3.4x. This achievement has been publicly recognized by the Ethereum Foundation, Vitalik Buterin, and Justin Drake.

5. Brevis Ecosystem Expansion and Application Implementation

Brevis's ZK data coprocessor (zkCoprocessor) handles complex computations that dApps cannot efficiently complete (such as historical behavior, cross-chain data, and aggregated analysis) and generates verifiable zero-knowledge proofs (ZKPs). Only this small proof needs to be verified on-chain to securely access the result, significantly reducing gas, latency, and trust costs. Compared to traditional oracles, Brevis provides not only "results" but also "mathematical guarantees of their correctness." Its main application scenarios can be categorized as follows:

• Intelligent DeFi: Based on historical behavior and market conditions, intelligent incentives and differentiated experiences are achieved (PancakeSwap, Uniswap, MetaMask, etc.)
• RWA & Stable Token Growth: Automated distribution of stablecoin and RWA revenue through ZK verification (OpenEden, Usual Money, MetaMask USD)
• Privacy Decentralized Exchange (DEX with Dark Pools): A privacy trading model that uses off-chain matching and on-chain verification, coming soon
• Cross-chain interoperability: Supports cross-chain re-staking and Rollup-L1 interoperability, building a shared security layer (Kernel, Celer, 0G)
• Blockchain Bootstrap: Using ZK incentives to help new blockchain ecosystems bootstrap and grow (Linea, TAC)
• High-performance public chains (100× Faster L1s): Promoting performance improvements for public chains like Ethereum and BNB Chain through real-time proof (RTP) technology
• Verifiable AI: Combining privacy protection with verifiable reasoning to provide trusted computing power for AgentFi and the data economy (Kaito, Trusta)

According to Brevis Explorer data, as of October 2025, the Brevis network has generated over 125 million ZK proofs, covering nearly 95,000 addresses and 96,000 application requests, serving a wide range of scenarios such as reward distribution, transaction verification, and proof of stake. Ecosystem-wide, the platform has distributed approximately $223 million in incentives, supporting over $2.8 billion in TVL, with cumulative trading volume exceeding $1 billion.

Currently, Brevis's ecological business mainly focuses on two major directions: DeFi incentive distribution and liquidity optimization. The core computing power consumption is contributed by four projects: Usual Money, PancakeSwap, Linea Ignition, and Incentra, accounting for a total of more than 85%.

• Usual Money (46.6M proofs): demonstrates long-term stability in large-scale incentive distribution;
• PancakeSwap (20.6M): reflects Brevis' high performance in real-time rate and discount calculations;
• Linea Ignition (20.4M): validates its high concurrency processing capabilities in L2 ecosystem activities;
• Incentra (15.2%): marks Brevis' evolution from an SDK tool to a standardized incentive platform.

In the field of DeFi incentives, Brevis relies on the Incentra platform to support multiple protocols to achieve transparent and continuous reward distribution:

• Usual Money's annual incentive scale exceeds $300M, providing sustainable returns for stablecoin users and LPs;
• OpenEden and Bedrock implement the distribution of US Treasury bonds and Restaking income based on the CPI model;
• Protocols such as Euler, Aave, and BeraBorrow use ZK to verify lending positions and reward calculations.

In terms of liquidity optimization, PancakeSwap, QuickSwap, THENA, Beefy, etc. use Brevis' dynamic rates and ALM incentive plug-ins to achieve transaction discounts and cross-chain revenue aggregation; Jojo Exchange and Uniswap Foundation use the ZK verification mechanism to build a more secure transaction incentive system.

At the cross-chain and infrastructure level, Brevis has expanded beyond Ethereum to include BNB Chain, Linea, Kernel DAO, TAC, and 0G, providing trusted computing and cross-chain verification capabilities for the multi-chain ecosystem. Meanwhile, projects such as Trusta AI, Kaito AI, and MetaMask are leveraging the ZK Data Coprocessor to build privacy-preserving points, influence scoring, and reward systems, driving the intelligent development of Web3 data. At the underlying system level, Brevis leverages the EigenLayer AVS network for re-staking security and incorporates NEBRA's aggregated proof (UPA) technology to compress multiple ZK proofs into a single submission, significantly reducing on-chain verification costs and latency.

Overall, Brevis covers a full range of application scenarios, from long-term incentives, event rewards, and transaction verification to platform-based services. Its high-frequency verification tasks and reusable circuit templates provide Pico/Prism with real-world performance pressure and optimization feedback. This is expected to feed back into the L1 zkVM real-time proof system at the engineering and ecosystem levels, forming a two-way flywheel of technology and application.

6. Team Background and Project Financing

Mo Dong｜Co-founder, Brevis Network

Dr. Mo Dong, co-founder of Brevis Network, holds a PhD in Computer Science from the University of Illinois at Urbana-Champaign (UIUC). His research has been published at top international academic conferences, adopted by tech companies like Google, and garnered thousands of citations. He is an expert in algorithmic game theory and protocol mechanism design, focusing on promoting the integration of zero-knowledge computing (ZK) with decentralized incentive mechanisms to build a trusted, verifiable compute economy. As a venture partner at IOSG Ventures, he has also long focused on early-stage investments in Web3 infrastructure.

The Brevis team was founded by PhDs in cryptography and computer science from UIUC, MIT, and UC Berkeley. Core members have years of research experience in zero-knowledge proofs (ZKPs) and distributed systems, and have published numerous peer-reviewed papers. Brevis has received technical recognition from the Ethereum Foundation, and its core modules are considered critical on-chain scalability infrastructure.

Brevis completed a $7.5 million seed round of financing in November 2024, co-led by Polychain Capital and Binance Labs, with participation from IOSG Ventures, Nomad Capital, HashKey, Bankless Ventures and strategic angel investors from Kyber, Babylon, Uniswap, Arbitrum, and AltLayer.

VII. ZKVM and ZK Coprocessor Market Competitive Analysis

Currently, ETHProofs.org, supported by the Ethereum Foundation, has become the core tracking platform for the L1 zkEVM Realtime Proving (RTP) route, used to publicly display the performance, security, and mainnet adaptation progress of various zkVMs.

Overall, competition in the RTP track is focusing on four core dimensions:

• Maturity: SP1 is the most mature for production deployment; Pico has leading performance and is close to the mainnet standard; RISC Zero is stable but RTP data is not public.
• Performance: Pico proof size is approximately 990 kB, which is approximately 33% smaller than SP1 (1.48 MB), and is lower in cost.
• Security and Audit: RISC Zero and SP1 have passed independent security audits; Pico is currently undergoing an audit.
• Development ecosystem: Mainstream zkVMs all use the RISC-V instruction set. SP1 relies on the Succinct Rollup SDK to form a broad integrated ecosystem. Pico supports Rust to automatically generate proofs, and the SDK is rapidly improving in terms of completeness.

Judging from the latest data, the current RTP track has formed a "two-strong pattern"

• The first-tier Brevis Pico (including Prism) and Succinct SP1 Hypercube both aim for the P99 ≤ 10s standard set by EF. The former achieves performance and cost breakthroughs through a distributed multi-GPU architecture, while the latter maintains engineering maturity and a robust ecosystem through a single system. Pico represents performance and architectural innovation, while SP1 stands for practicality and ecosystem leadership.
• The second-tier teams, RISC Zero, ZisK, and ZKM, continue to explore ecosystem compatibility and lightweight design, but have yet to disclose complete RTP metrics (latency, power consumption, CAPEX, security bits, proof size, and reproducibility). Scroll (Ceno) and Matter Labs (Airbender) are attempting to extend Rollup technology to the L1 verification layer, demonstrating the evolution from L2 capacity expansion to L1 verifiable computing.

By 2025, the zkVM market will have established a technological landscape characterized by RISC-V unification, modular evolution, recursive standardization, and hardware-accelerated parallelism. The zkVM's universal verifiable computing layer can be divided into three categories:

• Performance-oriented: Brevis Pico, SP1, Jolt, and Zisk focus on low latency and real-time proofs, improving computing throughput through recursive STARKs and GPU acceleration.
• Modularity and scalability: OpenVM, Pico, and SP1 emphasize modularity and pluggability, and support coprocessor access.
• Ecosystem and general development: RISC Zero, SP1, and ZiSK focus on SDK and language compatibility to promote universalization.

The current zk-coprocessor market is dominated by Brevis, Axiom, Herodotus, and Lagrange. Brevis leads the pack with its "ZK data coprocessor + general-purpose zkVM" architecture, combining historical data access, programmable computation, and L1 RTP capabilities. Axiom focuses on verifiable queries and circuit callbacks; Herodotus specializes in historical state access; and Lagrange optimizes cross-chain computing performance with its ZK+Optimistic hybrid architecture. Overall, zk-coprocessors are becoming a trusted computing interface connecting DeFi, Reliable Web Apps (RWA), AI, identity, and other applications as a "verifiable service layer."

8. Summary: Business Logic, Engineering Implementation, and Potential Risks

Business Logic: Performance Driven and Double Flywheel

Brevis builds a multi-chain trusted computing layer with "universal zkVM (Pico/Prism)" and "data coprocessor (zkCoprocessor)": the former solves the problem of verifiability of arbitrary calculations, and the latter realizes the business implementation of historical and cross-chain data.

Its growth logic forms a positive cycle of "performance-ecosystem-cost": Pico Prism's RTP performance attracts integration from leading protocols, leading to scale growth and reduced unit costs, forming a continuously strengthening double-layer flywheel. Its competitive advantages mainly lie in three aspects:

1. Reproducible performance — Incorporated into the Ethereum Foundation’s ETHProofs RTP system;
2. Architectural barriers - modular design and multi-GPU parallelization achieve high scalability;
3. Commercial verification - has been implemented on a large scale in incentive distribution, dynamic rates and cross-chain verification.

Engineering Implementation: From "Focusing on Execution" to "Replacing Execution with Verification"

Brevis leverages the Pico zkVM and Prism parallel framework to achieve an average time of 6.9 seconds and a P99 of less than 10 seconds on a 45M gas block (on a 64×5090 GPU, with a cost of less than $130K CAPEX), achieving leading performance and cost. The zkCoprocessor module supports historical data reading, circuit generation, and back-link verification, and can flexibly switch between Pure-ZK and Hybrid modes. Its overall performance is nearly aligned with Ethereum's hardened RTP standard.

Potential risks and key points of concern

• Technical and Compliance Thresholds: Brevis still needs to complete public and third-party verification of hard metrics such as power consumption, security bits, proof size, and trusted setup dependencies. Long-tail performance optimization remains key, and EIP adjustments may address performance bottlenecks.
• Competition and substitution risks: Succinct (SP1/Hypercube) still leads in tool chain and ecosystem integration, and the competitiveness of teams such as Risc Zero, Axiom, OpenVM, Scroll, and zkSync cannot be ignored.
• Revenue Concentration and Business Structure: Currently, proof volume is highly concentrated (the top four applications account for approximately 80%), requiring expansion across multiple industries, public chains, and use cases to reduce reliance. GPU costs may impact unit gross profit.

Overall, Brevis has established a preliminary competitive advantage in both reproducible performance and viable business applications. Pico/Prism have firmly established themselves in the leading tier of the L1 RTP market, while the zkCoprocessor is opening up high-frequency, reusable commercial scenarios. Going forward, we recommend achieving the Ethereum Foundation's full RTP hard target as a phased goal, continuously strengthening coprocessor product standardization and ecosystem expansion, while also promoting third-party reproducibility, security audits, and cost transparency. By achieving a structural balance between infrastructure and SaaS revenue, we can create a sustainable closed-loop business growth cycle.