Exclusive Interview with Brevis CEO Michael: zkVM Scaling Is Far More Effective Than L2

On consumer-grade hardware, 64 GPUs completed 99.6% of L1 block proofs within 12 seconds—Brevis’s multi-GPU zero-knowledge virtual machine (zkVM) Pico Prism has achieved a significant performance breakthrough.

This milestone has also attracted significant attention from the Ethereum core community. Ethereum co-founder Vitalik Buterin publicly commented: "I'm glad to see Brevis's Pico Prism officially entering the ZK-EVM verification field. This is an important step for ZK-EVM in terms of proving speed and diversity."

"The data speaks for itself." Brevis co-founder and CEO Michael stated, "We have built infrastructure capable of handling Ethereum’s real-time block production, all using consumer-grade hardware. This level of performance is the best response to Ethereum’s goal of decentralization."

Brevis co-founder and CEO Michael—PhD in Computer Science from UIUC, expert in distributed systems and high-performance networks—has founded and successfully exited multiple startups in Silicon Valley, with his research adopted by many tech giants including Google. In 2018, he founded Celer Network (with a peak valuation of over $2 billions). Now, he leads the Brevis team to combine zero-knowledge proofs with verifiable computation, aiming to build infrastructure that can truly support the large-scale computational needs of the Ethereum ecosystem.

To better understand how Brevis achieved this breakthrough and what it means for the Ethereum ecosystem, BlockBeats conducted an in-depth conversation with Brevis co-founder and CEO Michael.

We explored three core questions:

· Brevis’s mission and positioning

· The practical value verifiable computation can bring to applications

· Brevis’s next steps in deep alignment with the Ethereum ecosystem

This is not just a conversation about technology, but also a forward-looking reflection on the future of computational trust.

What is Brevis: From Vision to Positioning

BlockBeats: Could you first introduce, in the simplest terms, what kind of project Brevis is and what problems it aims to solve?

Michael: We position Brevis as an Infinite Computing Layer, serving Web3 as well as broader application scenarios. The core goal is to provide on-chain applications with nearly unlimited computational power while maintaining decentralization and security, addressing the structural contradiction where high performance/complex functionality and trust minimization have long been hard to achieve together. Although L2 scaling has significantly improved throughput in recent years, complex computations (such as large-scale historical data processing, cross-chain aggregation, algorithm/AI inference, etc.) are still limited, making it difficult for many advanced features to be implemented.

Brevis’s solution is off-chain computation, on-chain verification. Heavy computations are executed off-chain, generating zero-knowledge proofs (ZK Proofs); on-chain contracts only need to verify the correctness of the proof at extremely low cost, without repeating the entire computation. In this way, contracts essentially gain a cryptographically guaranteed plugin, significantly expanding available computing power and functional boundaries without sacrificing decentralization and security. Currently, smart contracts are not truly smart, but with Brevis, they can become genuinely intelligent.

BlockBeats: Brevis is called the Infinite Computing Layer for Web3. How did this concept come about? How is it fundamentally different from traditional on-chain computation or scaling?

Michael: We call Brevis the Infinite Computing Layer for Web3 because its goal is to break the computational ceiling of blockchains. Traditional scaling solutions (like Layer 2 Rollups) mainly improve transaction throughput, from dozens of TPS to hundreds or thousands, but there is still a ceiling, and they do not solve the problem of whether any complex computation can be completed on-chain: on-chain systems can usually only handle relatively simple transactions and contract operations. Once computational complexity increases, it is difficult to model and support on-chain, such as large-scale data processing, AI inference, or complex algorithms.

Brevis starts from a different point: We are not just making existing types of transactions run faster, but enabling blockchains to accept and carry the results of any computation, while maintaining security and trustlessness. This corresponds to a new paradigm of verifiable computing—so long as off-chain computation can produce a zero-knowledge mathematical proof, the chain can confirm its correctness and security at extremely low cost.

For developers, Brevis is more like a verifiable computing cloud: like using cloud computing to scale computing power on demand, putting complex computations off-chain, then submitting proofs on-chain for verification, while retaining the same security and trust model as native on-chain contracts. Therefore, we define Brevis as the Infinite Computing Layer—achieving nearly unlimited computational space in terms of performance and usability, while maintaining the same trust and security as the blockchain itself.

BlockBeats: The verifiable computing you just mentioned sounds abstract. Can you explain its role in Brevis in a more intuitive way?

Michael: The fundamental limitation of blockchains is that, while ensuring security and trustlessness, computational power is limited. Public chains like Ethereum are consensus systems, where a large number of nodes in the network each compute the same transaction or contract execution, and only after reaching consensus is a new block produced. This mechanism is secure but inefficient, similar to every student in a class solving the same problem from scratch to confirm the answer.

The idea of verifiable computing is to decouple computation and verification, reducing redundant overhead. Take the classic "chicken and rabbit in the same cage" math problem: solving it requires setting up equations and deriving, but verifying a given answer only requires plugging the numbers back into the equation, which is much less costly than solving it again. In computer science, computation and verification are inherently different problems, with the latter usually being lighter. Zero-knowledge proofs generalize this to any computation, whether it’s a simple operation like 1+1=2 or inference by a large model, allowing an additional concise proof to be generated after computation, so others can quickly verify at very low cost without revealing computation details.

In Brevis, heavy computations are executed off-chain and generate ZK proofs, while on-chain only verifies the proof, without repeating the entire computation. This is a core value of verifiable computing: by completely separating computation and verification, it greatly saves the cost of repeatedly computing the same target countless times.

Why Do This: Technical Architecture and Core Ideas

BlockBeats: On the technical level, Brevis consists of two core modules: the ZK Data Coprocessor (hereafter zkCoprocessor) and Pico zkVM. What is the relationship between these two? What problems do they solve respectively?

Michael: You can think of Brevis as a layered structure: at the bottom, Pico zkVM is a general-purpose computing engine (Virtual Machine), to which you can assign any computation and generate a zk Proof; one of its important features is high modularity, allowing multiple coprocessors to be attached. The zkCoprocessor is a coprocessor for blockchain data scenarios, which you can think of as a plugin or add-on. In its current form, zkCoprocessor is more like the memory system of zkVM, enabling smart contracts to see and understand historical events on-chain (such as user transactions, balances, holdings, etc.).

More specifically, zkVM solves the general problem of making any computation verifiable; zkCoprocessor is an application-layer coprocessor customized for blockchain applications. Since smart contracts naturally "live in the present," they can only access the limited context of the current block and cannot directly read or compute long time-window historical or cross-chain states; zkCoprocessor gives contracts "a pair of eyes" through zero-knowledge proofs, retrieving and aggregating relevant historical data off-chain and generating proofs that this data is authentic and comes from on-chain states, thus enabling contracts to have memory and memory-based intelligence while maintaining trust minimization.

BlockBeats: zkCoprocessor allows smart contracts to "see the past," which sounds very groundbreaking. Can you elaborate on how it achieves this?

Michael: Let’s take PancakeSwap’s dynamic fee discount based on historical trading volume as an example:

First, zkCoprocessor reads the user’s historical trading records from the blockchain, aggregates trading volume according to rules (such as the past 30 days), and generates a zero-knowledge proof for it;

Next, after receiving the authenticated records, Pico zkVM performs further aggregation and computation (for example, merging trading volumes of different pairs into a single metric), and generates a proof for the computation process;

Finally, the result + proof is submitted on-chain, and the contract verifies the correctness of both proofs in one go, confirming whether the address has reached the VIP threshold and automatically applying the fee discount for the next settlement period.

In this way, contracts do not need to repeatedly read and compute massive historical data on-chain, gaining the ability to see the past while maintaining trustlessness and cost control.

BlockBeats: You developed Pico zkVM yourselves instead of adopting other zkVM solutions. What was the reasoning behind this? How is Brevis different from other zk projects?

Michael: This is a very critical question. Indeed, there are already quite a few zkVM projects on the market, so why did Brevis build its own Pico zkVM from scratch? The core reason is simple—we believe that most existing zkVMs are still at the laboratory stage and are not truly designed for large-scale, real-world applications. In terms of performance, cost, and scalability, they are still far from being able to support large-scale commercial use. In other words, they are more like proofs of concept, not production-grade systems capable of supporting tens of millions of calls.

Brevis faced very real demand scenarios from the start. Leading DeFi protocols like PancakeSwap, Euler, Linea, Usual, etc., need to generate millions of zk proofs every day. If the underlying zkVM’s performance does not meet the standard, the entire system simply cannot go live. This forced us to rebuild a zk computing engine truly born for production environments—this is Pico zkVM.

Pico has three notable features. First is extreme performance. Pico is currently the world’s most powerful zkVM. Our latest release, Pico Prism, can already complete real-time proofs for 99.6% of Ethereum mainnet blocks on 64 5090 GPUs (within 12 seconds), with 96.8% of blocks completed within 10 seconds. This means a 3–4x performance improvement and about 50% reduction in hardware costs. In other words, if Ethereum ran on Pico today, its overall verification efficiency could increase by an order of magnitude—a true breakthrough in real-time proofs.

Second is its unique modular architecture. Pico is currently the only zkVM that supports external coprocessors; other zkVMs are usually closed structures that can only do general-purpose computation, while Pico can mount different modules for different application scenarios. For example, when accessing historical data, cross-verifying on-chain records, or running complex financial logic, Pico’s coprocessors can be plugged in like plugins, accelerating specific tasks. This gives Pico both general-purpose and specialized high-performance capabilities, flexibly covering applications from Web3 DeFi to Web2 AI computing and more.

Finally, it is developer-friendly. We don’t want developers to have to master cryptography or ZK theory to use Pico. Developers only need to know Rust to call it directly and write ZK applications as if writing ordinary programs. This greatly lowers the barrier and completely hides the complexity of ZK at the underlying level. So overall, we are not an experimental zkVM, but a ZK computing engine built for the real world and real use cases.

BlockBeats: Recently, your Pico Prism achieved 99.6% real-time proofs on consumer-grade hardware. Can you talk about the technical breakthroughs behind this achievement and what it means for the performance limits of zkVMs?

Michael: Let me first explain the importance of this. Performance improvement is not just about technical optimization, but about the future scaling and development of the Ethereum ecosystem. Ethereum’s current architecture requires every node to repeat the same computation, which is secure and reliable, but scalability is near its limit. The next step requires a new paradigm: a single node completes a large amount of computation and generates a ZK proof, while other nodes only verify. Through this single-point computation, multi-point verification approach, throughput can be increased by an order of magnitude while maintaining decentralization and security, even reaching or surpassing Solana’s level, while maintaining the necessary scale of decentralized nodes.

The Ethereum Foundation proposed a two-year goal this July: to achieve real-time proofs for 99% of blocks using consumer-grade hardware costing less than $100,000. Once achieved, nearly unlimited scaling can be obtained by stacking ordinary hardware computing power. However, before this, it was always considered theoretically possible: most zkVM solutions still fall significantly short of this standard in terms of coverage, cost, and speed, with many struggling to reach even 90% real-time coverage.

Pico Prism is the first system to truly cross this performance line. In our tests, using only 64 5090 GPUs (about $120,000 cost), we achieved 99.6% of Ethereum blocks being proven within 12 seconds, with 96.8% within 10 seconds, and an average proof time of just 6.9 seconds.

Compared to other protocols, Pico’s performance improved by 70% and costs were reduced by 50%. In other words, it is not only faster but also cheaper, meaning we are already very close to the goal set by the Ethereum Foundation.

BlockBeats: In terms of functionality and goals, is Brevis more like a ZK acceleration layer for Ethereum, or more like a verifiable computing cloud for multiple chains?

Michael: In terms of functionality and goals, these two positions are not in conflict. In the short term, Brevis is more like a ZK acceleration layer for Ethereum and its L2s. We are aligned with the Ethereum Foundation: using zero-knowledge proofs to achieve 10x to 100x scaling for the mainnet; at the same time, real-time proof capabilities will significantly improve the interactivity of L2 Rollups, making cross-chain speed faster, efficiency higher, costs lower, and promoting better unification of state and liquidity.

From a longer-term and broader perspective, Brevis’s positioning is not limited to Ethereum. Our architecture naturally supports multiple chains, and we are currently collaborating with ecosystem partners such as BNB Chain (e.g., PancakeSwap), and advancing perpetual contract projects on non-Ethereum chains; we are also aligned with L2/multi-chain ecosystems like Arbitrum, Base, Avalanche, etc. Overall, we hope to build Brevis into a verifiable computing cloud for all blockchain applications.

Our goal is that in the next 3–5 years, smart contracts deployed on any chain can easily use this computing service; in the longer term, the vast majority of blockchain application computation will occur off-chain and be guaranteed trustworthy via ZK, with Brevis serving as the unified computational trust layer for the entire decentralized system.

How to Land: Real Applications and Cases

BlockBeats: Many DeFi applications, such as PancakeSwap, Euler, or Linea, are already using Brevis’s technology. Can you give a concrete example of how it works in these scenarios?

Michael: Yes, our current application scenarios are mainly divided into several categories, with the most typical being DeFi. PancakeSwap, which was just mentioned, is a standard case. We don’t want the DEX user experience to always remain at the stage where everyone is treated the same—whether you are a regular trader or a high-frequency whale, the interface and rates are exactly the same. We hope DEXs can gradually become like CEXs, providing differentiated experiences for different types of users. At the same time, we are exploring more innovative applications. For example, collaborating with SocialFi projects to allow users to prove their influence and real holdings without exposing their main wallet.

We are also advancing scenarios that run almost entirely off-chain. For example, in perpetual trading systems like Hyperliquid, users’ positions and leverage information are often public, making it easy for other traders to attack. We hope to reconstruct such systems with ZK technology, allowing all orders and position records to be encrypted and hidden, but still guaranteeing the correctness of matching and system security through ZK proofs. This brings a smooth experience close to centralized trading platforms, while maintaining blockchain-level security and privacy.

BlockBeats: On the product level, Incentra is an important application you launched, which currently manages over $300 millions in incentive distribution. How does this system work?

Michael: The starting point of Incentra is simple: incentive distribution is the core of every ecosystem’s growth, but for a long time, distribution mechanisms have often had problems with security, compliance, and transparency.

Incentra’s core mechanism is that users generate ZK proofs based on their real on-chain or in-protocol behavior, and complete qualification verification and claiming directly on-chain, without relying on centralized distribution. Compared to traditional approaches, this model has three advantages. First, security: funds are settled in contracts according to preset rules, reducing centralized custody and operational risks; second, compliance and auditability: incentive rules and qualification proofs are all traceable on-chain, avoiding compliance pressure from transferring to unknown entities; third, fairness and transparency: any claim can be independently verified by outsiders for its real contribution and computation path, eliminating black-box distribution. Currently, this system has been implemented in growth and incentive scenarios for BNB Chain, MetaMask, OpenEden, Usual, and other projects. Whether in stablecoin ecosystems or on-chain incentive systems, this solution enables safe, compliant, and transparent incentive distribution.

BlockBeats: Compared to many ZK projects still at the laboratory stage, Brevis has already achieved large-scale implementation. Why do you think you were able to do this faster?

Michael: I think the core reason is that from day one, we never saw ourselves as a ZK research lab, but as an infrastructure company for real applications. Our technical route is not to build the engine first and then look for uses, but the other way around: starting from application needs and backtracking the design of the underlying architecture.

This actually determines the fundamental difference of Brevis. Many ZK projects develop a seemingly perfect zkVM behind closed doors, then think about where it can be applied; we start from the real pain points of partner projects, first understanding their actual needs, then gradually designing a modular zkVM architecture, and further creating a pluggable zkCoprocessor.

In other words, Brevis’s technological evolution is not planned out of thin air, but pushed forward step by step by real users and partners. This problem-driven R&D model allows us to iterate quickly, with each improvement directly corresponding to a verifiable use case. This also means our system has had production-level stability and scalability from the start, not just code written for papers.

There’s also a more straightforward reason: our team understands both cryptography and large-scale systems engineering. We never stay at the theoretical level, but truly polish performance and verify stability in production environments. So far, Brevis has generated over 100 million zero-knowledge proofs on mainnet, served about 190,000 users, and managed over $300 millions in real incentive funds for partner protocols. These are real live applications—including projects like Linea, Euler, Usual, OpenEden—not demos or testnets.

Where to Go Next: Open Scenarios and Future Vision

BlockBeats: Besides DeFi, in what other directions do you think the model of off-chain computation and on-chain verification can have an impact in the future, such as AI, data markets, or gaming?

Michael: Beyond DeFi, this model will have a lasting impact in verifiable AI, bridging Web2 to Web3 data and identity, privacy data markets, as well as gaming and social. First, in verifiable AI, existing models are mostly black boxes. With zero-knowledge proofs, mathematical evidence can be generated for the inference process, proving that a specific model produced a corresponding output for a given input, and ensuring the model and process were not replaced or tampered with. Second, in bridging Web2 to Web3, users can bring credentials or behaviors from centralized platforms into on-chain applications in the form of proofs, such as mapping trading activity on a centralized exchange to fee discounts on a decentralized exchange, without exposing identity or underlying account details. Finally, in gaming and social, users can prove their historical achievements, asset holdings, or completion of key actions to gain access, matching qualifications, or incentives, without disclosing wallets or sensitive personal information.

In the long run, this system will redefine the boundaries of trust in the digital world. We hope to use Web3 and zero-knowledge proofs to reconstruct the way human society understands trustworthy computation, so that every computation can be verified and trusted. What Brevis wants to do is to become the foundation of all this—the new computational trust layer.

BlockBeats: We saw that on October 13, Brevis launched the Brevis Proving Grounds event. Can you share the core content of this event and what users can actually participate in and experience?

Michael: Actually, in the past period, we have spent a lot of effort on validating real-world applications and documentation approval. Now we have deep collaborations with more than twenty partners, each project is a real live application scenario that users can directly use, and these projects have performed very well in terms of data and user retention.

But we found that in the blockchain world, many things are actually driven by user awareness pushing development. That is, when users truly understand the value of a new technology, their feedback and needs in turn drive developers to implement more features. For this reason, we want to really bring users in, making them not just bystanders but people who can personally experience and verify. This is the core purpose of our The Brevis Proving Grounds event.

The whole event is roughly divided into two stages. The first stage is user education, where we want more people to understand what our partners are actually doing and what specific problems zero-knowledge proofs (ZK) can solve in these projects. This stage is more about popularization and understanding, letting everyone clearly grasp the logic and significance behind the technology.

The second stage is the real experience stage, where users actually use the applications we have already implemented, truly feeling the changes brought by integrating Brevis. Unlike many projects, whose events usually just have users click buttons, complete tasks, and farm airdrops—because they often lack truly experiential, foundationally innovative features—our partner projects are real, valuable applications. When users participate, they are not playing a simulation, but truly using products deeply integrated with Brevis technology.

We hope that in this way, users can personally experience the smooth experience and value transformation brought by ZK technology, and understand why this model of off-chain computation and on-chain verification can make applications both secure and efficient. More importantly, we want to use this to make more users become drivers of the ecosystem: as more and more users understand and actively demand that the products they use adopt this mechanism, the entire industry’s innovation momentum will also be activated in reverse.

BlockBeats: Besides this event, does Brevis have any other plans? Can users still participate?

Michael: We will continue to launch participatory ecosystem plans, including advancing the launch of a decentralized proving node network to form a more open proving and verification infrastructure. Related plans will open participation channels to the community and ecosystem partners, with specific participation methods and timelines to be announced later.

BlockBeats: From a longer-term perspective, what kind of infrastructure do you hope Brevis will become? What role does it ultimately want to play in the Web3 world?

Michael: Our vision is to make Brevis the Infinite Computing Layer of Web3, the source of universal trusted computation. Just as Ethereum reconstructed the trust logic of assets and finance with smart contracts, Brevis aims to reconstruct the trust logic of computation: no longer choosing between computing yourself and trusting others’ results, but ensuring the security and correctness of results through verifiable computation without repeated execution.

Looking to the future, on-chain applications will evolve from simple transaction execution and asset transfer to more intelligent and complex systems, covering advanced algorithms, data interaction, personalized experiences, and social behavior proofs. To achieve large-scale adoption, both powerful computational capability and complete security are required. We want to make this proof-based computation universal, easy to use, and low-cost—so that every Web3 application can naturally embed this capability without reinventing the wheel.

From an architectural perspective, we hope to add a new trust layer—the Infinite Computing Layer—on top of the consensus, data, and execution layers. It will become the fourth foundational infrastructure of blockchains, providing unified computational trust and verification capabilities for the entire decentralized world. All intelligent, complex, and even cross-chain computations can be verified and used under zero trust assumptions. This is our understanding of infinite computing, and it is Brevis’s long-term mission.