1. The Thesis
RISC Zero isn’t trying to be the fastest prover. It’s trying to be the most useful one.
In a space where most ZK teams are building elegant, optimized puzzles, RISC Zero is building puzzle solvers infrastructure for the rest of us.
And the real bet? It’s not just on cryptography. It’s on distribution.
Their product, Boundless, is a decentralized proving network that lets anyone, rollups, oracles, AI agents, even full chains, outsource ZK proofs like compute jobs$^1$. Write your code in Rust. Submit a job. Get a STARK-based proof back. That’s it.
It’s AWS for ZK, if AWS were run by a decentralized GPU cluster.
If Boundless works, RISC Zero will become the layer below the execution layer, the invisible infrastructure that powers verifiable compute across chains and ecosystems. It’s not a rollup. It’s not an L1. It’s the thing they’ll all quietly rely on.
This flips the normal ZK playbook. Instead of competing on raw performance, RISC Zero competes on usability, generality, and plug-and-play distribution. And if they win, the rest of the stack just builds on top.
Of course, that’s the bullish case.
If proving doesn’t become a real market, if developers don’t want to rent verifiability the way they rent storage or bandwidth, then Boundless becomes a beautiful machine with no traffic.
The difference will come down to culture and timing, not just tech.
RISC Zero is betting that in the future, people won’t just want trustlessness, they’ll want receipts.
2. The Problem Worth Solving
Crypto talks a big game about trustlessness, but most of the stack still runs on trust.
→ We trust sequencers to order transactions honestly.
→ We trust bridges to report balances correctly.
→ We trust AI agents to act without tampering.
→ We even trust oracles, apps, and precompiles to do what they claim they do.
And if you look closely? That trust is either hardcoded or off-chain, assumptions you can’t verify, even if you wanted to.
ZK proofs could fix all of this. They give us the ability to prove that a computation was done correctly, without revealing anything else.
But here’s the catch: Using ZK today still feels like writing firmware in assembly$^2$.
You either build brittle app-specific circuits, which are fast but hard to maintain…
Or you try to wrangle general-purpose provers that are expensive, slow, and require deep cryptographic understanding.
Most teams don’t have the time or appetite for either. So the result? Most of the “trustless” infra in crypto today simply isn’t verifiable. It could be, but it isn’t.
That’s the real opportunity. RISC Zero flips the model. Instead of telling developers to learn ZK, it says:
“Write your logic in Rust, we’ll handle the proving.”$^1$
And if you need more speed, plug into Boundless, the proving marketplace where specialized nodes compete to generate your proof faster, cheaper, and with real SLAs.$^3$
ZK becomes invisible infrastructure. Not a feature. Not a bottleneck. Just a service.
If this works, ZK stops being a research field and starts becoming a utility.
3. How It Works, and Where the Edges Are
Let’s keep it simple: RISC Zero lets you write normal Rust code, run it in a virtual machine, and generate a zero-knowledge proof that the code executed correctly, no cryptography degree required.
At the core is their zkVM, a general-purpose proving engine that emulates a RISC-V processor$^4$. That means it can execute pretty much any logic you write, and turn the result into a verifiable proof.
But it’s not just a proving engine. It’s an actual developer stack, end to end.
- zkVM - The execution engine, built for Rust, powered by STARKs under the hood.
- Steel - Their Rust-based SDK that makes writing zk apps feel like building CLI tools.
- Bonsai - A hosted proving service for teams that want speed and simplicity.
- Boundless - The decentralized network where anyone can submit a job, and provers race to complete it and earn ZKC.
It’s clean, opinionated infrastructure, and way more approachable than most ZK stacks out there.
Analogy: If proving is compute, zkVM is the CPU, Steel is your dev toolkit, and Boundless is the cloud you deploy to.
Now, what’s clever here is the abstraction.
You’re not building circuits, you’re writing apps. You don’t manage hardware, you just send a job.
But like any abstraction, it comes with trade-offs.
Where the edges start to show:
- Performance isn’t top-tier - especially compared to app-specific circuits. You’re paying for generality.
- Proofs can be slow for complex jobs - ZK compute still isn’t “fast” unless you optimize heavily.
- zkVM doesn’t yet have a formal proof of zero-knowledge - it’s performant and open source, but not academically airtight.$^5$
- Bonsai vs. Boundless - there’s real tension between a centralized proving service (great UX) and a decentralized network (credibly neutral). Which one wins out isn’t obvious.
This isn’t a silver bullet. It’s a bet that abstraction and accessibility will win, even if you give up some raw performance.
It’s the same bet the EVM made. Not the best execution environment, just the most usable one.
If Boundless works, this becomes the default stack for teams who want verifiability without the pain.
If it doesn’t? RISC Zero risks becoming yet another beautifully engineered zkVM that no one outside the crypto dev inner circle adopts.
4. Why This Time Is Different
This isn’t the first attempt at generalized proving. We’ve seen zkVMs before. We’ve seen marketplaces before. So what makes Boundless, and this entire approach, viable now?
Let’s break it down.
i. ZK is finally usable by normal developers
Three years ago, writing a zk app meant learning custom DSLs, writing circuits from scratch, and navigating documentation that felt like academic PDFs.
Today? With RISC Zero, you just write Rust. The SDK (Steel) abstracts away proving logic. The zkVM compiles your program.$^6$
The prover (Bonsai or Boundless) gives you a STARK proof you can post anywhere.
No custom circuits. No constraint fiddling.
This is the first time ZK feels like something a product engineer can ship in a sprint.
ii. The proving model is modular, not monolithic
Boundless isn’t just a hosted prover. It’s a marketplace.
You don’t rely on one centralized prover (like many zk-rollups still do). You get job routing, load balancing, and real-time competition between nodes, all paid in ZKC.$^3$
That opens up new design space:
- Use RISC Zero as a backend for rollups without running your own prover infra.
- Offload oracle logic to Boundless and return proofs to chains.
- Run complex AI inference off-chain and publish verifiable results.
This is compute as a service, but built on cryptographic guarantees.
iii. There’s finally demand for off-chain verifiability
The rise of AI agents, DePIN, oracles, modular rollups, they all need one thing in common: a way to prove what happened off-chain.$^7$
And they don’t want to re-execute. They want proof artifacts. That’s where RISC Zero fits.
You feed in a job, anything from model inference to bridge validation, and get back a verifiable receipt.
This is a new kind of infra primitive:
Not “run your app on a blockchain”, but “prove it ran correctly and let the chain verify.”
The trust moves off-chain. The guarantees stay on-chain.
iv. RISC Zero is distribution-aware
This is subtle but important.
Most ZK teams ship great proving tech, then expect the world to adopt it.
RISC Zero ships great proving tech and builds the on-ramps: SDKs, hosted endpoints, dev tooling, documentation, and now Boundless as the go-to-market layer.$^1$
They’re not just building an engine. They’re building the app store, the cloud dashboard, and the user onboarding funnel.
That’s what makes this more than a research project.
If you tried to launch Boundless two years ago, no one would have shown up.
Today? The stack is modular. The devs are hungry. The demand is finally real.
This isn’t a ZK breakthrough. It’s a timing breakthrough.
5. The Competition Reality Check
Boundless isn’t launching into a vacuum. ZK is hot. zkVMs are everywhere. Everyone wants to be “the prover layer.” So how does RISC Zero stack up?
Let’s go head-to-head with the three most relevant players:
i. RISC Zero vs. SP1 (Succinct)
SP1 is a rising open-source zkVM from Succinct, fast, elegant, and built from scratch with provability in mind$^8$. It’s gaining traction fast.
Where SP1 wins:
- Built for performance
- Strong formal proofs
- Clean modular design
Where RISC Zero wins:
- Real-world integrations (EigenLayer, Taiko, Celestia)$^9$
- Easier dev experience via Rust SDK
- Boundless: A built-in proving distribution layer
Succinct is building provers.
RISC Zero is building provers plus a marketplace.
That’s the edge. It’s not just tech, it’s routing, incentives, and usage.
ii. RISC Zero vs. Boojum (zkSync)
Boojum is zkSync’s high-performance in-house prover, optimized for their stack, and recently open-sourced.¹⁰ It’s blazingly fast.
But there’s a catch: It’s optimized for zkSync, not general-purpose use. You’re inheriting a lot of assumptions from their stack.
RISC Zero is slower… but it’s neutral.
You can use it from any chain, for any logic, with no dependency on an L2’s roadmap or politics.
If Boojum is the Tesla Roadster, RISC Zero is the white-label Toyota engine.
iii. RISC Zero vs. Cairo (StarkWare)
Cairo is the OG, powering StarkNet, custom-designed for zk-friendly logic.¹¹
But here’s the problem: You have to learn Cairo. And it’s… weird.
It’s powerful, no doubt. But the learning curve is steep, and portability is limited.
RISC Zero says: just write Rust.
If Cairo is like writing bytecode, RISC Zero is like scripting in Python.
Bigger Picture: zkVMs vs. app-specific circuits
There’s also a more fundamental competition: General-purpose vs. app-specific.
Teams like =nil; Foundation or Polygon Zero push hard on custom circuits for performance. It’s faster, but brittle. You’re locked into one use case.
RISC Zero trades off speed for flexibility. That bet only pays off if usage fragments, and developers want one prover for everything.
And right now? That’s exactly what’s happening.
The real risk?
If SP1 or other zkVMs become dominant, and Boundless doesn’t integrate them, it becomes “RISC Zero’s network”, not the proving network.
That fractures the market. Developers might love Boundless, but if they prefer another zkVM, they’re out.
RISC Zero wins if Boundless becomes multi-zkVM. Otherwise, it’s just vertical integration in disguise.
6. Economics and Traction
Let’s start with the basics: RISC Zero has a token. But not yet a token economy.
The token is called ZKC, short for ZK Compute. It’ll power Boundless: the decentralized proving network. But right now, it’s still pre-launch. No live emissions. No open markets. Just private allocations, testnet incentives, and infrastructure being wired up behind the scenes.
That makes this section part analysis, part forecast.
Token Utility
Here’s what ZKC is meant to do:
- Payment token: Clients pay ZKC to submit jobs to the Boundless network.
- Staking asset: Provers stake ZKC to participate and earn jobs. Slashing applies for faulty or slow proofs.
- Reputation signal: Over time, higher-staked nodes with a clean track record likely get priority in job routing.
ZKC turns trustless compute into a coordination game.
What’s not clear yet?
Whether ZKC will also capture platform fees, or if that revenue stays with the network participants (and not token holders).
It’s also unclear how governance fits in, or whether there will be a DAO-like layer for protocol upgrades and treasury usage.
Supply and Emissions
No public tokenomics yet, but some signals:
- A testnet incentive program is live (July 2025) with rewards paid in future ZKC allocations.$^1$$^2$
- Validator onboarding requires stake, but amounts and slashing rules haven’t been finalized.
- Founding investors likely hold a significant portion, but vesting schedules aren’t disclosed.
If you’re tracking token supply, emissions, or runway, you’ll need to wait for the launch docs.
Revenue Model
This is clearer:
- Bonsai (centralized) earns usage-based fees.
- Boundless (decentralized) will operate on a fee-for-service basis, where clients pay ZKC to get jobs done, and provers earn ZKC by doing the work.
No protocol revenue yet. No take-rate announced.
But the idea is simple: ZK proving as a marketplace. Just like blockspace, but for computation.
The risk?
If job demand doesn’t scale fast, the marketplace becomes a tokenized ghost town, provers farming testnet rewards with no real economic activity.
Traction So Far
This part’s promising.
- Rollup pilots: Taiko uses RISC Zero as a proving backend.$^1$$^3$
- Data availability: Celestia’s blobstream relies on RISC Zero for validator verification.
- Restaking logic: EigenLayer uses RISC Zero for proving off-chain slashing conditions.
- AI inference: Multiple demos show off ML models wrapped in zkVMs, from image classifiers to decision trees.
Plus, the testnet has seen consistent activity since its launch in Q2 2025.
Over 400 active provers have onboarded.$^1$$^4$
But we’re still early. Mainnet is coming. The real question is who builds on Boundless, and whether anyone pays for those proofs.
ZKC isn’t just a gas token. It’s an early bet on verifiability as a primitive.
If Boundless becomes a real economy, ZKC becomes the currency of truth.
If not, it’s just another stake-to-participate token, waiting for demand that never shows up.
Footnotes
- RISC Zero – Boundless Incentives Announcement, July 2025
- Boundless Explorer – Testnet Dashboard, last accessed Aug 1, 2025
- a16z – Portfolio Note: RISC Zero (April 2023)
7. Why These People Might Actually Pull It Off
Every ZK team sounds brilliant on paper, but very few actually ship. Even fewer build things other teams want to use.
RISC Zero’s edge? They do both.
The Builders
The project is led by Brian Retford and Jeremy Bruestle, seasoned engineers with deep systems experience. Jeremy was formerly Chief Architect at Webroot and brings decades of low-level compute background. Brian’s worked across multiple startups and open-source foundations.
These aren’t cryptographers publishing whitepapers. They’re builders. Tooling-first, product-oriented, relentlessly shipping.
What stands out is their bias for developer experience.
From Steel (the Rust SDK) to the clean zkVM APIs to the Boundless job submission CLI, the team actually cares about usability. You can feel it.
Most ZK projects are built by researchers. RISC Zero feels built by devs, for devs.
The Backers
They’re not undercapitalized either.
- a16z Crypto led the $40M Series A back in April 2023¹
- Participation from Geometry, Samsung Next, RockawayX, and others
- Strong engineering support and ecosystem connections
It’s not just capital. It’s alignment.
a16z has other ZK bets (Lagrange, Aleo, Espresso) but they’ve positioned RISC Zero as the infrastructure layer, the boring, useful thing that powers many bets.
The Execution Track Record
Let’s zoom out:
- zkVM: Live and fully open source.
- Steel SDK: Already used by multiple dev teams.
- Bonsai (centralized prover): Operational since early 2024.
- Boundless (decentralized): Testnet live, growing steadily.
- Integrations: With Celestia, Taiko, EigenLayer, and multiple AI inference demos.
This is not a whitepaper protocol. It’s a shipping protocol.
They didn’t raise and disappear for 2 years. They’ve released iteratively, each step building toward the larger vision.
Ecosystem Leverage
RISC Zero isn’t trying to own the whole stack. They’re positioning themselves as infra glue.
You’re building a rollup? Use RISC Zero for proving. You’re shipping an oracle? Prove your fetch. You’re launching an AI agent? Wrap your model execution in a zkVM.
They don’t need to win the application layer.
They just need to power the people who do.
This is what lets RISC Zero stay relevant, even if someone else builds the next big ZK app.
Is this a guaranteed win? No.
- They’re juggling both centralized and decentralized paths.
- Boundless is still pre-mainnet.
- And the token strategy hasn’t been battle-tested.
But compared to the average ZK team? They’ve done more, shipped more, and helped more other teams win. That counts.
8. The Three Assumptions This Entire Bet Relies On
Every protocol is a bet on a future that doesn’t exist yet. For RISC Zero, that future depends on three big assumptions, and if any one of them breaks, the whole thesis starts to wobble.
Let’s get into them.
i. Developers actually want to prove off-chain computation
This is the heart of it. If ZK proves anything, it’s that we can turn trust into math.
But math is expensive. And today, most developers just… don’t care.
They’d rather ship fast than prove everything. They’ll trust an API. Or a sequencer. Or a bridge relayer. It’s “good enough.”
So Boundless only works if that attitude changes, if provable compute becomes the norm, not the niche.
This is the cultural bet: that teams will want receipts, not just results.
That could happen via regulation (e.g. auditability requirements), economic pressure (slashing conditions for misbehavior), or just better dev tooling that makes proving the default.
But it has to happen. Otherwise, Boundless is solving a problem most teams don’t think they have.
ii. Proving becomes a real market, not a race to zero
Boundless introduces supply-side dynamics: provers competing for jobs, staking ZKC, getting slashed for errors or latency.
But that assumes there’s meaningful demand, that developers submit jobs, pay for them, and care about prover performance.
If the demand side doesn’t grow fast enough, the network stagnates.
Early provers get bored. Token incentives wear thin.
It becomes another staking scheme with no economic gravity.
This is the economic bet: that proving becomes like compute, metered, competitive, and valuable.
And importantly: that the token (ZKC) reflects that value, not just speculation.
iii. RISC Zero becomes the default zkVM, or Boundless becomes multi-zkVM
Right now, Boundless is tightly coupled to RISC Zero’s own zkVM.
That works… as long as RISC Zero remains competitive with SP1, Boojum, and whatever new zkVM hits GitHub next quarter.
But what if it doesn’t?
If developers prefer SP1 for speed, or Boojum for tight L2 integration, and Boundless doesn’t support those zkVMs… the whole “universal proving marketplace” collapses into vertical integration.
That would kill its biggest advantage.
This is the architectural bet: that Boundless becomes a protocol, not a product.
They’ve hinted at supporting multiple zkVMs, but it’s not live yet.
If they ship it, game on. If not, they risk shrinking their own market.
These three assumptions aren’t just technical.
They’re cultural, economic, and architectural.
And they determine whether Boundless is a critical layer of the future internet — or just a clean proving stack with no real traffic.
9. Where This Breaks, and How You’ll Know
Every protocol has a weak spot. And in ZK infra, you usually don’t find out until after a whole ecosystem is already depending on it.
So what could go wrong with RISC Zero and Boundless, and how would we know before it’s too late?
Failure Mode #1: Boundless becomes a ghost town
Boundless only works if it attracts two sides:
- Developers who submit jobs and pay for verifiable compute
- Provers who compete to do that work and earn ZKC
If either side dries up, the flywheel stalls. Warning signs:
- Flatlining job submissions on the explorer
- Low prover participation despite incentive programs
- No named integrations outside of RISC Zero ecosystem tools
- Bots gaming testnet rewards without real usage
If Boundless doesn’t become a real economy, it’s just a demo, not infrastructure.
Failure Mode #2: zkVM falls behind
General-purpose zkVMs are a fast-moving race. SP1 is getting faster. Boojum is battle-tested. And every few months, a new proving engine promises 10x performance.
If RISC Zero’s zkVM stagnates, developers will look elsewhere. And Boundless, tied to that VM, becomes collateral damage.
Warning signs:
- Benchmarks that lag significantly behind peers
- Lack of cross-compatibility with other zkVMs
- Integrations only coming from friendly ecosystems, not neutral adopters
This is especially dangerous if Boundless stays single-VM.
Being fast matters. Being interoperable might matter more.
Failure Mode #3: ZKC becomes just another utility token
ZKC has to do something. It needs to coordinate provers, incentivize accuracy, and reflect demand for verifiable compute. If it just becomes a speculative asset, or worse, a ghost asset with no usage, Boundless loses its economic backbone.
Warning signs:
- No staking or slashing mechanics live post-mainnet
- Most ZKC usage = farming or airdrop speculation
- No real price signals on proving latency or job complexity
- Low job throughput despite large market cap
If ZKC isn’t used like gas, it’s just hype.
Failure Mode #4: Too many moving parts, not enough focus
zkVM. Bonsai. Boundless. Steel. Rust SDKs. Dev tools. It’s a powerful stack, but it’s a lot.
RISC Zero could spread itself too thin, chasing integration wins without nailing product-market fit in any one area.
Warning signs:
- Multiple product surfaces with inconsistent adoption
- Delays in mainnet launches or SDK upgrades
- Developer confusion around where to start or what’s stable
- Heavy reliance on grant incentives to stimulate usage
A great team can ship fast. But even great teams can over-ship and under-align.
The Bottom Line:
This doesn’t die from a hack. It dies from irrelevance.
No traction. No demand. No usage. That’s how proving infra fades out, quietly.
The good news?
All of these failure modes are trackable. You’ll see them coming, if you’re looking.
10. My Prediction, and What Changes My Mind
Boundless is the most ambitious proving project in crypto. Not because the tech is exotic. But because the design is economic. This isn’t just about ZK. It’s about turning proving into a real-time, decentralized, monetizable service, like bandwidth or storage.
That’s a massive unlock.
My bet: RISC Zero will become the default proving network for off-chain applications.
Not rollups. Not DeFi.
But everything outside the chain, AI inference, oracles, bridge validation, autonomous agents, the off-chain logic that needs receipts.
That’s where RISC Zero wins. It won’t be the fastest zkVM. SP1 might beat it. It won’t own the biggest L2s. Boojum will dominate there.
And it won’t matter, because Boundless is going after a different axis of trust.
They’re not selling a prover. They’re selling verifiability as a service.
What Would Change My Mind?
I’ll turn bearish if:
- Boundless fails to attract non-RISC Zero integrations
- ZKC launches and becomes pure speculation, not usage
- No adoption beyond rollups or crypto-native tools
- The zkVM performance gap widens and developers opt out
- They don’t move toward supporting other zkVMs
If 12 months from now, Boundless is still just a RISC Zero playground, not a neutral proving network, the thesis breaks.
But if they keep shipping, keep onboarding new proving use cases, and make ZK feel like a normal part of dev infra?
Then Boundless might become something way bigger than another protocol. It might become how we prove the internet’s work.
Footnotes
- RISC Zero Blog – “The Road to Boundless”
- Succinct Labs Blog – “Introducing SP1: A performant, 100% open-source, contributor-friendly zkVM”
- RISC Zero Blog – “Introducing Boundless: The Verifiable Compute Layer”
- RISC Zero GitHub Repository – https://github.com/risc0/risc0
- RISC Zero Developer Docs – “Cryptographic Security Model”
- RISC Zero Docs - Boundless and Steel
- a16z Crypto – “State of Crypto Report 2024”
- Succinct Blog - “SP1: A New zkVM”
- RISC Zero blog - “Scaling Eigenlayer’s Security”
- Matter Labs | Q1 2025 Deliverables Report
- Cairo Docs - https://www.cairo-lang.org
- Coindesk - “Risc Zero’s ‘Boundless’ Incentivized Testnet Goes Live”
- Taiko Blog - “Taiko’s Approach to Multi-Proofs”
- Boundless Explorer – https://explorer.boundless.risczero.com
Originally published through Hiraku Research, an independent long-form research project I previously ran.