The Boundless Protocol: A Decentralized Marketplace for Scalable, Trustless Compute

Abstract

The Boundless Protocol introduces a decentralized marketplace for scalable, trustless compute by leveraging zero-knowledge proofs (ZKPs) and a novel Proof of Verifiable Work (PoVW) mechanism. Traditional cloud computing demands implicit trust in providers, while on-chain execution suffers from limited capacity and cost inefficiencies. Boundless addresses this gap by transforming verifiable computation into a liquid, financialized commodity accessible across blockchains.

By combining smart contracts, reverse Dutch auctions, and programmable service agreements, Boundless enables requestors to outsource compute securely, while provers compete to fulfill workloads using consumer-grade or cloud hardware. The system ensures fairness through slashing, retry mechanisms, and cryptographically auditable proof cycles. PoVW aligns incentives by rewarding provers based on delivered value and actual work performed, creating a dynamic and decentralized market for ZK compute.

Boundless also integrates a governance-controlled $ZKC token, allowing stakeholders to lock capital in a Vault to earn fee-sharing rights and influence protocol parameters. The protocol’s open design, formal verification standards, and commitment to permissionless participation make it a foundational infrastructure layer for the future of verifiable, scalable, and decentralized computation.

Introduction: The Need for Trustless Compute

The online world is experiencing swift development, with an ever-increasing demand for computational resources that are both scalable and trustworthy.

• Cloud computing offers economies of scale but requires implicit trust in providers.
• On-chain execution is trustless but limited in computational capacity.
• Ethereum’s gas market prioritizes high-margin workloads, excluding others.

The Boundless Solution

Boundless proposes:

• A decentralized marketplace
• Aggregation mechanisms
• Smart contract settlement
• Scaling for ZK-powered verifiable compute on every chain

This transforms compute from a scarce, privileged resource into an abundant, tradable commodity, powered by cryptographic truth rather than trust in intermediaries. Boundless introduces a fully decentralized compute verification system that allows any protocol to outsource workloads while preserving guarantees around correctness and censorship resistance.

To further illustrate this unique positioning, a comparative analysis of compute trust models is presented below:

Comparative Analysis: Compute Trust Models

This table highlights how Boundless occupies a unique and advantageous position. It combines the scalability typically associated with traditional cloud environments with the trustlessness and censorship resistance inherent to blockchain technology, all while mitigating the respective drawbacks of each. This foundational understanding is crucial for appreciating the subsequent detailed explanations of the protocol's mechanisms.

The Boundless Protocol: Core Architecture and Mechanisms

Boundless is built to support a decentralized, efficient market for verifiable computation. It uses both technical and economic tools to achieve this.

Decentralized Marketplace Design

Boundless creates a peer-to-peer market where:

• Requestors (those who need computations) interact directly with
• Provers (those who do the computing).

This interaction is managed by smart contracts, removing the need for a central authority. By treating zero-knowledge (ZK) proof work as a tradable asset, Boundless makes verifiable compute more accessible and inclusive for anyone who wants to participate.

Smart Contract Settlement and Multi-Chain Deployments

Smart contracts are central to how Boundless works. They handle:

• Escrow (holding funds safely),
• Settlements (paying for completed work),
• Audits (checking correctness of results).

Boundless is also multi-chain it runs on multiple blockchains. Each deployment benefits from the security and reliability of the host chain. This avoids the need to create a new consensus system and allows Boundless to expand faster while staying secure. It also adds redundancy and access to a wider range of blockchain users.

Spot Market and Reverse Dutch Auction Mechanics

Verifiable Service Agreements (VSAs)

VSAs are long-term contracts between requestors and provers. They’re like subscription deals or SLAs:

• A requestor can pay upfront for a set number of computations over time.
• This gives predictable access to compute resources.

VSAs can also be packaged and resold, creating a secondary market. For example:

• A developer can lock in future compute capacity, then resell unused portions to smaller users.

Combining spot auctions (for immediate jobs) with VSAs (for long-term needs) gives Boundless a flexible and stable market structure. This setup helps reduce price swings and ensures reliable access to compute resources.

By making compute contracts tradable, Boundless introduces new financial tools and strategies for users, turning compute into more than just a cost—it becomes an asset.

VSAs are fully integrated with Boundless’s systems for escrow, settlement, and verification. They also tie into the Proof of Verifiable Work (PoVW) and Vault components for security and accountability.

Mechanism Summary Table

The Trust Challenge in Computing

Contrasting Trust Models

Traditional and decentralized systems take fundamentally different approaches to trust:

• Cloud Computing relies on trusting the provider to execute code honestly and safeguard sensitive data.
• Blockchain Protocols replace that trust with protocol-enforced guarantees, where network nodes re-execute computations to independently verify correctness.

The Bottleneck

While effective for trust, the blockchain model of verification-by-re-execution introduces a major scalability constraint:

• It severely limits on-chain throughput due to redundant computation.
• Scarcity of execution space drives a competitive gas market, which prioritizes short, high-value transactions leaving many applications priced out.

Zero-Knowledge Proofs to the Rescue

Zero-Knowledge Proofs (ZKPs) offer a breakthrough solution:

• They allow a prover to demonstrate the correctness of a computation without revealing the data or re-running the process.
• This eliminates the need for re-execution, preserving trust without sacrificing performance.

Why ZKPs Matter

• Enable horizontal scalability by decoupling verification from execution
• Allow trustless collaboration between unknown participants
• Deliver objective truth in computation, ideal for decentralized marketplaces without intermediaries

ZKPs transform computation from a trust-based model into a verifiable-by-default paradigm, unlocking new possibilities for secure, scalable, and decentralized systems.

The Evolution of ZK Technology: From Theory to Practice

Zero-Knowledge Proofs (ZKPs) have transformed from abstract cryptographic concepts into usable technologies powering real-world systems. This journey includes key theoretical breakthroughs and practical tools that made ZK accessible to developers and protocols.

From Cryptographic Origins to General-Purpose Systems

ZKPs started with limited use cases mostly tied to cryptographic functions like RSA and ECDSA. But progress in Probabilistically Checkable Proofs (PCPs) laid the foundation for more expressive and efficient ZK systems.

Over the past decade, the following milestones have shaped ZK’s practical adoption:

• Zcash (2016) – First production-grade use of ZKPs for private crypto transactions.
• Bulletproofs (2018) – Removed the need for trusted setups in range proofs, making ZK more secure and easier to deploy.
• Circom & SnarkJS (2019) – Simplified ZK circuit development, broadening accessibility to non-expert developers.
• Halo (2019) – Introduced recursive proofs without trusted setup, allowing composable and scalable proof systems.
• STARKs & CairoVM (2020) – Delivered post-quantum security and scalable compute, thanks to StarkWare’s Cairo virtual machine.
• RISC-V (2022) – Enabled ZK proofs for general-purpose code written in Rust and RISC-V, expanding flexibility.
• Zeth (2023) – A rapid, high-performance zkEVM that demonstrated compatibility with Ethereum’s ecosystem.

Each breakthrough lowered technical barriers, shifting ZK from theory to an open development frontier.

The Last Hurdle: Integrating ZK into Real Applications

Despite these innovations, one major challenge remained: end-to-end integration of ZK into usable applications.

Problems included:

• A lack of decentralized provers
• Poor incentive alignment for compute providers
• No native marketplace for ZK compute
• High complexity in managing ZK tools and infrastructure

Boundless Protocol: Closing the Loop

Boundless solves this final integration problem by creating the infrastructure layer that connects ZK provers with real demand.

Here’s what it offers:

• A marketplace for provable compute jobs
• An incentive system (Proof of Verifiable Work) to reward correct computation
• A platform that abstracts away ZK complexity for developers

Boundless doesn’t build new proving systems—it leverages zkVMs, zkEVMs, and Cairo to offer scalable, trustless compute. As ZK tooling improves, Boundless benefits directly by expanding its capabilities and user base.

What’s Still Missing In The Decentralized Proof Equation?

• Writing code is easy; integrating proof production is not.
• Challenges include:
  • Lack of decentralized provers
  • Disconnected incentive structures
  • No native marketplace for verifiable compute
  • Infrastructure complexity, especially around control flow

Security Risks and Mitigations

• Requestor griefing: Withholding input data after provers lock requests.
• Proof duplication or falsification: Mitigated via embedded nonce and cycle metadata.
• Slashing: Punishes missed deadlines, but must be applied carefully.
• Boundless uses formal verification and an ecosystem of trusted tools (e.g., Circom, zkVM, zkLLVM) to ensure secure execution.

Boundless Marketplace: A Decentralized ZK-Powered Solution

Key Innovations

• Boundless Decentralized marketplace comprises of provers, requestors, and smart contracts.
• Verifiable compute is offered on demand Permissionlessly.
• Financialization of compute: turns ZK proof work into a commodity.
• Multi-chain deployments, with each instance independently inheriting the security and liveness properties of its host chain.

Marketplace Features

• Spot market for immediate requests
• Service agreements for long-term capacity
• Provers can respond to any network deployment with available capacity.
• Requestors benefit from global compute liquidity and failover redundancy.

Proof of Verifiable Work (PoVW)

Core Mechanism
PoVW is the foundation of Boundless' rewards and security model. It measures the actual computational effort behind each proof by:

• Counting the number of cycles executed by the zkVM
• Rewarding real work, rather than speed or reputation alone

This ensures that contributions are tied directly to verifiable computation.

Reward Calculation
Token rewards are distributed per epoch and are calculated based on two key metrics:

• The prover's percentage of total zkVM cycles
• The prover's percentage of total fees served

Each prover receives rewards based on the lower of the two proportions, ensuring a balance between performance and demand fulfillment.

• Any excess tokens are burned, discouraging strategic overfitting to either metric and maintaining economic equilibrium.

Security via Cryptography
Every proof includes:

• A cycle count
• A nonce to prevent duplication

This design ensures:

• No double-counting or proof reuse
• Full auditability and fraud resistance, enforced by cryptographic integrity

ZK Mining
PoVW introduces a new, permissionless form of mining:

• Anyone with capable hardware and zk skills can participate
• Unlike Bitcoin or Ethereum, PoVW is based on provable computation, not brute-force hashing

This model opens the door for decentralized, merit-based participation in the growing market for verifiable compute.

Verifiable Service Agreements

What They Enable

• Custom, long-term compute commitments between provers and requestors.
• Modeled like futures or SLAs.

Examples

• Alice pays Charlie upfront for 100 proofs over 12 months.
• Pam, a protocol developer, bundles SLAs to guarantee supply.
  • Later resells excess capacity to smaller users.
  • Creates a secondary market for compute.

Infrastructure

• Uses Boundless smart contracts for escrow, settlement, and audit.
• Integrates with the PoVW and Vault systems.

Decentralization and Market Dynamics

Open Access
Boundless is designed for open participation. Anyone can join the network to:

• Submit computation requests
• Become a prover, using devices like MacBooks, gaming PCs, or cloud-based VMs
• Earn ZK mining rewards for generating verifiable proofs

Market Correction and Competition
The protocol ensures healthy market dynamics:

• If a single prover gains dominance and inflates prices, new provers can enter the market and offer lower rates, restoring balance
• Incentive mechanisms are built in to discourage monopolistic behavior and promote long-term decentralization

Roles in the Ecosystem

• Provers: Generate ZK proofs and earn $ZKC tokens
• Requestors: Purchase compute power at transparent, market-driven prices
• Traders: Hedge compute exposure and trade service-level agreements (SLAs)
• Governance Participants: Vote to adjust key protocol parameters

Compute Liquidity = Market Stability
A deep, liquid compute market enables:

• Stable pricing
• Efficient resource allocation
• Robust resistance to centralization or manipulation

Boundless aligns incentives to create a truly open, decentralized, and economically resilient ecosystem for verifiable computation.

Implementation and Community Engagement

Open Development

• All contracts and client tools are open-source at https://beboundless.xyz .

Formal Verification

• Boundless prioritizes high-assurance code, working with:
  • Nethermind
  • Veridise
  • Runtime Verification
  • Ethereum Foundation

Conclusion: Realizing the ZK Future

Boundless marks a major leap forward in scaling and decentralizing verifiable computation. It addresses key barriers to widespread ZK adoption by:

• Solving integration challenges for zero-knowledge systems
• Balancing performance, trust, and economic incentives
• Enabling a new ecosystem for decentralized, verifiable compute

This is achieved through a powerful combination of mechanisms:

• Proof of Verifiable Work – ensuring integrity through cryptographic accountability
• Reverse Dutch Auctions with Retry Slashing – optimizing cost-efficiency and deterring manipulation
• Tokenized and Stakable Compute Markets – aligning incentives and enabling open participation
• Permissionless Architecture – allowing anyone to join, contribute, and earn
• Formal Verification Standards – raising the bar for security and correctness

Boundless unlocks a world where compute is trustless, abundant, and accessible to all.

Key Sources

1. A curated list of awesome web3 formal verification resources – including tools, tutorials, articles and more.https://github.com/johnsonstephan/awesome-web3-formal-verification
2. Veridise: A smart contract audit means blockchain security https://veridise.com/
3. Smart Contract Audit Methodology | Runtime Verification Inc, https://runtimeverification.com/smartcontract-analysis
4. Boundless Docs: What is Boundless?, https://docs.beboundless.xyz
5. Formally Verifying the Security Properties of INTMAX2 - Nethermind, https://www.nethermind.io/blog/formally-verifying-the-security-properties-of-intmax2