InfrastructureIntermediate

ZK Coprocessors Guide 2026: Offchain Compute, Onchain Proof

Q: What is a ZK coprocessor?

A ZK coprocessor is a system that performs expensive offchain computation and generates a zero-knowledge proof that the computation was performed correctly. A smart contract verifies the proof onchain, trusting the result without re-running the computation. They unlock offchain access to historical blockchain data, complex analytics, and heavy math for onchain applications.

Q: How do ZK coprocessors differ from oracles like Chainlink?

Oracles bring external data into smart contracts and rely on a trusted reputation model. ZK coprocessors compute on blockchain data already available and provide cryptographic proof of correct execution — no trust required. Coprocessors access historical blockchain state; oracles fetch current external data. Different tools for different problems.

Q: Which ZK coprocessor project is the most advanced?

Succinct's SP1 leads in production deployment with 1.48MB proof sizes and open-source code. Brevis achieved 96.8% real-time proving (RTP) coverage on mainnet with 6.9s average proof time on a 64×5090 GPU cluster. Axiom pioneered ZK queries for Ethereum. Each project excels at different tradeoffs — choose based on your application's needs.

Q: Do I need to understand zero-knowledge proofs to use ZK coprocessors?

No. Users interact with the end result — verified computation results onchain. Developers using the APIs (Axiom Query Engine, Brevis SDK, RISC Zero Steel) don't need to understand the cryptography deeply. The ZK verification is abstracted away by the protocol.

Q: How much does it cost to use a ZK coprocessor?

Proof generation costs vary by project and proof size. Axiom charges per query verified onchain. Brevis's Pico prover runs at lower cost with 33% smaller proofs. SP1 has transparent benchmarks available. For most applications, the cost trades off favorably against the gas savings from offchain computation — you'd pay far more to run equivalent logic onchain.

Q: Will ZK coprocessors make blockchain faster?

Not directly — they don't speed up settlement. But they enable applications that were impossible or prohibitively expensive onchain: loyalty rewards based on historical data, dynamic DeFi rates, cross-chain identity verification. They don't make blocks faster; they make smart contracts smarter.

Smart contracts are limited computers. ZK coprocessors let them offload expensive computation offchain, then verify the result with a cryptographic proof. No trust required. Access to history. Capability that wasn’t possible before.

Published March 24, 2026 · 15 min read

1. What Are ZK Coprocessors?

A ZK coprocessor is like a GPU for blockchain. Smart contracts are Turing-complete but economically constrained: every computation costs gas, and that cost scales with complexity. A contract can’t efficiently query "what was the average gas price over the last 30 days?" or "did this address interact with protocol X in the past 12 months?" or "prove this ML model outputs value Y for input X." Running complex computation onchain is prohibitively expensive.

ZK coprocessors offload expensive computation offchain. A specialized system (the prover) fetches blockchain data, runs the computation, and generates a zero-knowledge proof — a cryptographic artifact that proves the computation was performed correctly, without revealing intermediate steps or requiring re-execution.

The proof is posted to the blockchain and verified by a smart contract. The contract gets the result — with absolute cryptographic certainty that the computation was correct. No trust in the prover. No re-execution. Just verification that takes milliseconds and costs a fraction of the original computation.

⚡ ZK Coprocessors at a Glance

Computation Location

Offchain (prover)

Verification

Onchain (smart contract)

Data Source

Blockchain history

Trust Model

Cryptographic

Proof Time

Seconds to minutes

Verification Cost

~200k–2M gas

2. Why Smart Contracts Need Coprocessors

Smart contracts today suffer from a fundamental limitation: they can only see the current block state. A contract deployed on Ethereum can access today’s balances, today’s exchange rates, today’s gas price. But it has no direct way to query historical data without massive inefficiency.

To answer "how much stETH did this address hold on average over the last 90 days?", you’d need to manually iterate through thousands of historical blocks, store data onchain, and pay gas for each read. To verify "did this account transact on Uniswap in 2024?", you’d scan logs of millions of events. This isn’t impractical due to computation limits — it’s impractical because of cost.

ZK coprocessors solve this by giving smart contracts "memory" and "intelligence". A contract can now:

Access historical blockchain data: Prove facts about any past block, account balance, or transaction
Run complex analytics: Calculate averages, percentiles, volatility, custom aggregations
Verify cross-chain state: Prove events on one chain to another without bridges
Perform heavy math: Run complex algorithms (ML models, simulations, cryptographic operations) and prove the output

The result is a new category of applications: dynamic DeFi that responds to historical volatility, loyalty protocols that track interaction history without expensive onchain logging, and MEV protection that proves fair ordering across chains. These weren’t possible before ZK coprocessors.

3. How ZK Coprocessors Work

The system follows a three-step process:

Smart Contract Defines a Query

A contract needs some computation — e.g., 'prove that address 0x123 held at least 100 ETH on average in March 2026.' The contract calls the coprocessor interface with the query parameters.

Offchain Prover Executes & Proves

A specialized system (operated by the coprocessor network) fetches all relevant blockchain data, runs the computation deterministically, and generates a ZK proof. The proof cryptographically encodes: 'I computed this correctly, using this data, and got this output.'

Onchain Verification

The proof is posted to the blockchain. The smart contract's verifier function checks the proof in milliseconds. If valid, the contract trusts the output and continues execution. The entire process is trustless — the contract never relies on the prover's reputation.

The evolution path: zkRollups (batch transactions) → zkVM (general-purpose computation) → zkCoprocessor (outsourced computation for contracts) → L1 zkEVM (rollup as L1). Each layer builds on ZK technology but solves different problems. Coprocessors don’t replace rollups — they complement them by making individual smart contracts smarter.

4. Key Projects Building ZK Coprocessors

Six major teams are shipping ZK coprocessor infrastructure. Each takes a different architectural approach:

Axiom

Verifiable queries for Ethereum history

Pioneered the ZK query paradigm — contracts call Axiom to prove facts about Ethereum history
Query types: balances, transaction counts, event logs, storage values at any historical block
Handles the hardest part: verifying Ethereum's Merkle-Patricia trie structure offchain
Elegant API: contracts define queries, Axiom generates proofs, callback returns result
Production: Shipping on mainnet, used by dapps for loyalty, governance, and analytics

Brevis

Hybrid ZK + optimistic architecture with ultra-fast proving

Two-in-one: ZK Data Coprocessor (Ethereum state queries) + general-purpose zkVM
Brevis Pico prover: 6.9s average proof time, 990kB proof size (33% smaller than competitors)
Hybrid design: Uses optimistic + ZK verification for some operations, reducing latency
96.8% real-time proving (RTP) coverage on a 64×5090 GPU cluster — approaching block time speeds
Production: Mainnet deployments for MEV protection, cross-chain apps, and DeFi strategies

Herodotus

Storage proofs specialist — prove historical blockchain state across chains

Expert in Merkle-based storage proofs — proving that a value existed at a specific block
Handles chain-specific state structures: Ethereum, Starknet, and more
Enables use case: 'Prove I held 10 ETH on Ethereum on date X' to prove eligibility on another chain
Focus: Cross-chain identity, airdrop eligibility verification, state attestation
Production: Live on mainnet with storage proof infrastructure

Lagrange

ZK + optimistic hybrid for cross-chain computation

Focuses on cross-chain state verification and computation
Hybrid verifier: combines ZK proofs with optimistic fraud-proof fallback
Backed by 1kx and Founders Fund — strong thesis in cross-chain verification
Targets: proof aggregation across multiple blockchains, unified state verification
Early production: Testing with early partners on mainnet

RISC Zero

General-purpose zkVM with Ethereum integration (Steel)

Flexible zkVM: can prove any Rust computation, not just blockchain-specific queries
Steel framework: lets zkVM proofs call Ethereum view functions and read contract state
Advantage: arbitrary custom computation without designing a domain-specific circuit
Strong academic backing and proven benchmarks on general computation
Production: Stable, but hasn't publicly disclosed real-time proving benchmarks yet

Succinct (SP1)

Open-source zkVM leading in production deployment

SP1: High-performance, open-source RISC-V zkVM
Proof size: 1.48MB (competitive), transparent benchmarks, active community
Deployed on mainnet for bridge verification and proving systems
Advantage: open-source means ecosystem can build on top
Strong focus on production readiness and performance optimization

5. Real-World Use Cases

ZK coprocessors unlock applications that were impossible or prohibitively expensive before:

🎁 DeFi Loyalty & Retroactive Rewards

Prove you provided liquidity for X consecutive days without tracking onchain. Reward protocols can issue retroactive airdrops to historical participants by querying their transaction history and generating ZK proofs of contribution.

🔗 Cross-Chain Identity Verification

Prove you hold NFTs or tokens on one chain to unlock access or benefits on another. Use storage proofs to verify wallet state across chains without wrapped tokens or bridge contracts.

📊 Data-Driven DeFi

Set interest rates dynamically based on historical volatility. A lending protocol can query 30 days of price history for an asset, calculate volatility via ZK coprocessor, and adjust collateral requirements in real-time.

🛡️ MEV Protection & Fair Ordering

Prove transaction ordering was fair and MEV-resistant across multiple chains. Protocols like MEV-Share can verify that block builders didn't reorder transactions for profit.

🗳️ ZK-Powered Governance

Delegate governance voting based on historical contribution, not just current balance. A DAO can prove you were an active contributor in Q1 2026 and grant voting weight accordingly.

🤖 AI Model Verification

Prove a machine learning model produces a specific output for a given input, then submit that proof to a smart contract for decision-making. Enables trustless AI-powered DeFi.

6. ZK Coprocessors vs. Oracles vs. zkRollups

These three technologies are often confused because they all involve blockchains and cryptography. Here’s how they differ:

Dimension	ZK Coprocessor	Oracle (Chainlink)	zkRollup
Data Source	Blockchain history (L1 state)	External APIs, real-world data	User transactions
Trust Model	Cryptographic (ZK proof)	Reputation + economic incentives	Cryptographic (ZK proof)
Primary Use	Offchain computation for contracts	Price feeds, external events	Layer 2 scaling & batching
Latency	Seconds to minutes (proof gen)	Milliseconds to seconds	12–60 seconds (batches)
Cost per Query	~200k–2M gas verification	~5k–50k gas per feed	~0.01% of L1 cost (shared)
What You Verify	Computation correctness	Oracle reputation & signatures	All L2 transactions at once

The key distinction: Oracles solve the "bring external data in" problem. Coprocessors solve the "compute on blockchain data offchain, verify the result" problem. Rollups solve the "scale transaction throughput" problem. A single application might use all three — an L2 perpetuals dex could use Chainlink for price feeds (oracle), a ZK coprocessor for volatility calculations, and operate entirely on an Arbitrum rollup for scaling.

7. The Road to Real-Time Proving

The Ethereum Foundation has been funding research into real-time proving (RTP) — the vision that every Ethereum block would be proven (with ZK proofs) as soon as it’s finalized. This would enable:

Instant L2 finality: Rollups could finalize to L1 in one slot instead of 12+ days
Superlight clients: Verify Ethereum with 1KB of data instead of gigabytes
zkEVM: A fully ZK-proven Ethereum equivalent — proving all computation in real-time
Cross-chain bridging: Trustless, instant bridges between any two chains via ZK proofs

Progress is accelerating. Brevis Pico achieved 96.8% RTP coverage on mainnet using a 64×NVIDIA RTX 5090 GPU cluster, with an average proof time of 6.9 seconds per block. That’s close to real-time — Ethereum blocks arrive every 12 seconds, so a single GPU cluster can keep up.

The hardware requirements are substantial (high-end GPU clusters), but the trajectory is clear. As proving algorithms improve and specialized hardware arrives (ASICs for ZK proof generation), real-time proving will become cheaper and more accessible. The endpoint is a blockchain ecosystem where every block is cryptographically proven and verifiable with minimal data — fundamentally changing how we think about light clients, cross-chain security, and L1/L2 relationships.

8. Risks and Limitations

ZK coprocessors are powerful but not without challenges:

⚠️ Prover Centralization

Today, only a few teams operate mainnet provers. If all provers go offline, coprocessor queries fail. Long-term vision is decentralized prover networks (like Ethereum's validators), but that's years away.

⚠️ Hardware Requirements

Proof generation requires GPUs and specialized hardware. Running a competitive prover network demands capital investment. This raises barriers to entry compared to oracle networks.

⚠️ Proof Generation Cost

Generating a proof isn't free. The cost currently ranges from cents to dollars per proof, depending on complexity. For high-volume applications, this can exceed onchain computation costs.

⚠️ Nascent Ecosystem

The technology is 2–3 years old. Bugs and exploits are possible. Coprocessor infrastructure hasn't undergone the rigorous long-term testing Ethereum itself has received.

⚠️ Smart Contract Risks

Risk is relocated to the verifier contracts themselves. A vulnerability in the ZK verification logic (a valid risk — see curve pairing bugs) could break the security model entirely.

⚠️ Latency

Proving takes seconds to minutes. If you need sub-second computation, coprocessors aren't the answer. For now, they're optimized for outcomes you can afford to wait for.

9. How to Get Started with ZK Coprocessors

For Developers:

Axiom

Build with Axiom's TypeScript query API. Define what blockchain facts you need, submit to Axiom, receive proofs that verify onchain. Excellent documentation and examples.

→ axiom.xyz/query

Brevis

Use the Brevis SDK for both queries and general computation. Hybrid approach: use Brevis for both Ethereum state queries and arbitrary offchain logic.

→ brevis.io/docs

RISC Zero

Steel framework: write Rust code that calls Ethereum view functions, generate proofs that the computation is correct. Best for arbitrary custom logic.

→ risczero.com/steel

Succinct (SP1)

Open-source zkVM. Write Rust, prove anything. Active documentation and community. Good for understanding how provers work under the hood.

→ docs.succinct.xyz

For Users: Most users won’t interact with coprocessors directly — they’ll use dapps that are powered by coprocessor technology. Watch for dapps announcing ZK coprocessor integrations in 2026–2027. Loyalty protocols, cross-chain identity, and data-driven DeFi will be the first mass-market use cases you see.

10. Frequently Asked Questions

What is a ZK coprocessor?

A ZK coprocessor performs expensive offchain computation and generates a zero-knowledge proof proving the computation was correct. Smart contracts verify the proof onchain, trusting the result without re-execution. They enable contracts to access blockchain history, run complex analytics, and perform heavy computation — all trustlessly.

How do ZK coprocessors differ from oracles like Chainlink?

Oracles bring external data (price feeds, event data) into smart contracts. Coprocessors compute on blockchain data already available and provide cryptographic proof. Oracles say 'here's the data'; coprocessors say 'here's the computation result, verified.' Different problems, complementary solutions.

Which ZK coprocessor project is the most advanced?

Succinct SP1 leads in production deployment and open-source adoption. Brevis achieved 96.8% real-time proving coverage. Axiom pioneered the query paradigm. Each excels at different tradeoffs — choose based on your application's requirements. No single clear winner yet; the ecosystem is still proving out approaches.

Do I need to understand zero-knowledge proofs to use ZK coprocessors?

No. Users and dapp developers interact with high-level APIs. The cryptography is abstracted away. Axiom's query API, Brevis SDK, and RISC Zero's Steel all hide the ZK complexity behind developer-friendly interfaces.

How much does it cost to use a ZK coprocessor?

Axiom charges per query verified onchain. Brevis's Pico prover offers competitive pricing. Exact costs vary by proof complexity. For most applications, offchain computation + onchain verification is far cheaper than running equivalent logic entirely onchain.

Will ZK coprocessors make blockchain faster?

Not directly. They don't reduce settlement time or block time. But they enable smarter contracts that were impossible before — loyalty tracking, cross-chain identity, dynamic DeFi. They make the blockchain more capable, not faster.