Proofs Complete Within 12-Second Window with Push

Zero-knowledge proof generation presents considerable timing and reliability challenges for modern blockchain systems. Mohsen Ahmadvand, Rok Pajnič, and Ching-Lun Chiu, all from Zircuit, address these issues in a new study detailing push0, a scalable and fault-tolerant orchestration system for zero-knowledge proof generation. This research is significant because delayed proofs impact finality and incur economic losses in ZK-rollups, while Ethereum’s zkEVM demands proof completion within strict slot windows for stateless validation. The team’s work introduces a cloud-native system decoupling prover binaries from scheduling infrastructure, employing an event-driven architecture to enforce sequential proving alongside intra-block parallelism. Validated through production Kubernetes cluster experiments and deployment on the Zircuit zkrollup since March 2025, push0 demonstrates negligible orchestration overhead and high scaling efficiency, offering scheduling primitives suitable for both centralised and decentralised proving networks.

Imagine coordinating hundreds of chefs to prepare a single dish, each needing precise instructions delivered at exactly the right moment. Building secure blockchain systems demands similar precision, requiring complex calculations to be completed and verified with minimal delay. This new system streamlines that process, enabling faster and more reliable zero-knowledge proof generation for emerging technologies.

Scientists are increasingly focused on scaling blockchain systems using zero-knowledge proofs (ZKPs). These proofs, a foundational primitive for both privacy and scalability, are becoming central to Ethereum’s development with applications in ZK-rollups and the emerging L1 zkEVM. Both technologies demand timely proof generation; rollups require swift proofs to avoid delays in finalizing transactions and potential economic losses, while the zkEVM aims to complete proof generation within Ethereum’s 12-second slot window for stateless validation.

Recent work, including the Ethereum Foundation’s Ethproofs initiative, has demonstrated the feasibility of real-time block proving using multiple independent zkVMs, yet a thorough orchestration framework to manage these complex systems has remained elusive. Existing solutions struggle to address the combined challenges of maintaining strict head-of-chain ordering, adhering to sub-slot latency bounds, automatically reassigning tasks in case of failure, and accommodating diverse, prover-agnostic workflows.

Researchers have introduced push0, a cloud-native proof orchestration system designed to decouple prover binaries from the underlying scheduling infrastructure. This system employs an event-driven dispatcher-collector architecture built upon persistent priority queues, enabling block-sequential proving alongside intra-block parallelism. The development of push0 began with a formalization of requirements derived from operating a production ZK-rollup and analysing the Ethereum real-time proving specification.

By identifying a core tension, the need for strict ordering versus maximal concurrency, the team designed an architecture that allows for unlimited parallelism within a block while enforcing sequential proof submission between blocks. Experiments within production Kubernetes clusters reveal push0 achieves a median orchestration overhead of 5ms, with 99, 100% scaling efficiency at 32 dispatchers for realistic workloads.

At a performance level, this overhead is negligible, representing less than 0.1% of typical proof computation times which often exceed 7 seconds. Production deployment on the Zircuit zkrollup, processing over 14 million mainnet blocks since March 2025, provides real-world validation of these findings. In the end, push0’s design supports smooth integration of heterogeneous zkVMs, automatic task recovery through message persistence, and the scheduling primitives needed for both centralized rollup operators and decentralized multi-prover networks.

Kubernetes and Zircuit deployment demonstrate minimal overhead and near-linear scaling

Median orchestration overhead reached 5ms, as demonstrated through production Kubernetes cluster experiments utilising 32 dispatchers for realistic workloads. This negligible overhead, less than 0.1% relative to typical proof computation times exceeding 7 seconds, highlights the system’s efficiency. Controlled Docker experiments corroborated these findings, exhibiting comparable performance of 3, 10ms P50 when eliminating network variance.

Also, production deployment on the Zircuit zkrollup, processing over 14 million mainnet blocks since March 2025, validates these controlled experimental results in a live environment. The system achieves 99, 100% scaling efficiency at 32 dispatchers, indicating a near-linear increase in throughput as resources are added. At this scale, push0 maintains consistent performance without bottlenecks, important for handling increasing transaction volumes.

The design supports smooth integration of diverse zkVMs, allowing operators to benefit from advancements in cryptographic technology without infrastructure modifications. By employing an event-driven dispatcher-collector architecture over persistent priority queues, push0 enforces block-sequential proving while simultaneously exploiting intra-block parallelism.

The research formalised requirements derived from operating a production ZK-rollup and the Ethereum real-time proving specification. These requirements encompass head-of-chain ordering, bounded latency, fault tolerance, prover agnosticism, horizontal scalability, and observability. Automatic task recovery is enabled through message persistence, ensuring no work is lost due to failures.

Beyond simple task recovery, push0 provides the scheduling primitives necessary for both centralized rollup operators and decentralised multi-prover networks. The system’s architecture allows for the distribution of proving tasks across multiple independent zkVM implementations, mirroring the Ethereum Foundation’s Ethproofs initiative. Unlike existing solutions, push0 addresses the critical orchestration gaps of strict block ordering, ad-hoc failover, and integration of new zkVMs. Where other systems focus on either throughput or latency, push0 prioritises both, delivering a balanced solution for demanding blockchain applications.

Zero-knowledge proof task scheduling via prioritised message aggregation

A persistent priority queue architecture underpins push0, a cloud-native proof orchestration system designed to manage zero-knowledge (ZK) proof generation. This system decouples prover binaries from the scheduling infrastructure, allowing for flexible deployment and management of heterogeneous zkVMs. Dispatchers initially receive proving tasks and immediately enqueue them onto dedicated priority queues, categorised by block number and task metadata.

These messages contain specific fields necessary for downstream processing and deduplication, ensuring each task is processed only once. Collectors extract a configurable grouping key from each message payload to determine aggregation groups, rejecting mismatched inputs and logging discrepancies. At-most-once aggregation is guaranteed through a deduplication cache keyed by message ID, discarding redundant results from potential message redelivery.

Each incoming message is then passed to a collection strategy’s collect() method, which can either accumulate the message, finish aggregation and emit results, postpone processing, or discard the message entirely. For recursive proof composition, the strategy waits for a predefined number of subproofs sharing a common grouping field before completing the aggregation barrier.

Push0 offers two prover integration modes to balance ease of use with performance. The JSON Executor allows integration of any prover via a file-based interface, requiring minimal adaptation for provers with non-conforming command-line interfaces. Dispatchers invoke the prover binary using std::process::Command, capturing exit codes and output paths.

Alternatively, the Composer Executor enables native integration for provers available as Rust libraries, directly invoking a prove() function and eliminating file I/O and JSON serialization overhead. Workflow specification within push0 is realised implicitly through queue topology and collection strategy configuration, forming a directed acyclic graph (DAG) where nodes represent task types and edges signify data dependencies.

For a typical zkEVM pipeline, this might include witness generation, parallel subproof generation, and recursive aggregation of subproofs into a succinct proof. A production deployment example illustrates two parallel tracks, a proposer flow handling metadata and a proving flow generating cryptographic proofs, synchronised by aggregator collectors, demonstrating the system’s capacity for complex, multi-stage pipelines.

Engineering zero-knowledge proof generation for scalable blockchains

Once a futuristic promise, zero-knowledge proofs are rapidly becoming a bedrock of blockchain scalability, yet realising their potential demands solving problems beyond the mathematics. For years, the bottleneck hasn’t been creating these proofs of data validity, but orchestrating their creation quickly and reliably enough to keep pace with live transactions.

This work addresses that critical, often overlooked, engineering challenge with a system called push0, and its impact could extend far beyond simply speeding up rollups. Instead of focusing on faster proving algorithms, the researchers tackled the messy business of managing the computational resources needed to generate proofs. The difficulty lies in the need for both strict ordering, proofs must be generated in the correct sequence to maintain blockchain integrity, and high throughput.

Balancing these requirements, while also accommodating potential failures and integrating different proving technologies, is a complex undertaking. Push0 demonstrates a system capable of handling this orchestration with minimal overhead, a result achieved through a clever event-driven architecture and persistent queuing. The true power of this approach isn’t just speed; it’s adaptability.

Unlike systems tightly coupled to specific proving methods, push0 is designed to accommodate a variety of “zkVMs”, paving the way for a more diverse and competitive field of zero-knowledge technologies. Since the system was deployed on a live zkRollup, the ecological validity of the results is strong, moving beyond theoretical performance gains to demonstrate real-world effectiveness.

Questions remain regarding the scalability of the orchestration layer itself as the demands on proving clusters increase. Beyond this, the broader field will likely see a shift towards more specialised hardware designed to accelerate proof generation, and push0’s flexible architecture should allow it to integrate with these advances. The focus may turn to automating the selection of the most efficient zkVM for a given task, creating a truly active and optimised proving ecosystem.