The Master Plan

Where Are We Today?

Sixteen years into blockchain’s evolution, its promises are finally being taken seriously by both governments and individuals. As the social layer of humanity warms up to the technology, blockchain is finding its market fit through seamless, borderless payments, sovereign ownership, and decentralized identification—establishing itself as a new financial layer for the Internet. Through blockchain, applications can efficiently and affordably reach global markets, allowing users to step outside local economies and embrace novel concepts of digital ownership. It represents the culmination of the Internet’s original promise.

Yet, despite blockchain’s growing potential, adoption remains frustratingly slow. So why, after sixteen years, are we not witnessing waves of innovation? Regulatory constraints have certainly played a role in suppressing growth, but they do not account for the lack of innovation.

Widespread innovation is unlocked by two things: the technology being fundamentally capable, and the technology being simple to use.

The need for the technology to be fundamentally capable is straightforward but why does simplicity matter? Almost everyone loves simple, so simple makes more products possible that more people will use. The success of cloud infrastructure and SaaS in Web2 was not due to enabling new possibilities, but because those things made innovating with existing capabilities simple.

Is blockchain simple? Either to develop on or use? You know the answer to that one.

Is blockchain technology today capable of everything it needs to do? The next wave of blockchain adoption will be characterized by businesses using the technology to access the benefits uniquely provided by it. This transition will see businesses run more of their payment infrastructure onchain, pulling customers onchain in the process. As consumer to business payments moves onchain, so will business to bank and consumer to bank asset management. Onchain bank to bank settlements will either lead or quickly follow, with central bank deposits and settlements along side them. But can we really have all of this payment data onchain, from consumers to businesses to commercial banks to the central banks, without privacy? No. Every one of those entities, individuals included, will want privacy of their transactions and accounts. Privacy at scale will require at least this functionality supporting billions of users interacting with millions of businesses globally, at the rate of billions of transactions per day.

So, we must ask: What technologies must be built to support this future? And what happens when deploying blockchain applications becomes as effortless as deploying to the cloud?

If we solve these gaps, we and what we build will bring the future forward.

What Does the Future Look Like?

But the future is much bigger than private payments at scale. If we step back and observe humanity’s broader technological trajectory, we can see that blockchain will be far more foundational. Technology and its increasing accessibility has consistently elevated global living standards. Innovation stagnation is coming to an end, driven by AI’s ability to democratize knowledge, reducing barriers and accelerating iteration cycles. At the same time, blockchain is solidifying its role as the financial backbone of the Internet. Where we are headed is a truly global economy, where geography no longer limits access to financial systems, information, or computing power.

A few years ago, the idea of personal AI agents autonomously managing daily life—completely abstracting away financial transactions—seemed like a cyberpunk future. Yet today, AI-driven agents are already experimenting with social and agentic autonomy, with blockchains providing them the power to transact.

In this future, the financial and data layers of society merge. Natural language and thought become the primary interfaces between humans and computation. The implications are profound: radical advancements in healthcare, education, and industry will accelerate the quality of life growth, globally.

As incredible a future as this will be, it is also one of vast centralizing forces.

AI will become integrated into daily life as a digital companion to our existence. People will welcome its convenience—frictionless experiences, instant fulfillment of desires, and a world that seemingly caters to their needs.

But beneath this seamless transformation lurks an existential danger. Every fragment of digital existence will be captured, cataloged, and controlled. If unchecked, those with massive computational resources will consolidate power, monopolizing data and exerting total dominance over human society.

As the financial layer digitizes and AI governs all interactions, absolute power will belong to those who control the data.

Why What We Are Doing Is Important

Decentralized and permissionless systems are our tools to maintaining our sovereignty with privacy and control over one’s data being the key to maintaining our freedom. Blockchain is the cornerstone in this future that we are now running toward—a belief once confined to crypto purists, but now recognized by individuals and governments alike.

This shift is already in motion. Stablecoin usage surpasses Visa’s transaction volumes, allowing people to exit restrictive local economies and businesses to seamlessly access global markets. Bitcoin is increasingly viewed as a superior store of value, with governments considering state-sponsored reserves. Meanwhile, the world’s largest institutions are actively working to tokenize every asset class.

Even if the full optimistic vision of blockchain never materializes, integrating an asset transaction layer into human society represents a logical and irreversible milestone.

Yet, the more likely outcome is that blockchain’s cryptographic foundation will become the primary defense against fraudulent content, disinformation, and digital manipulation. Blockchain is poised to become the universal standard for verifiability.

This cyberpunk-ish vision is quickly becoming the logical future from where we stand today. As we witness a surge in Web2 companies acquiring blockchain companies, the US actively positions itself to lead the world in crypto and AI, and governments everywhere bring crypto policy to the forefront, we must prepare.

This is just the beginning. If we don’t execute now, to build the foundations we need today, humanity will go down the wrong path.

Where Is the Gap?

Despite an explosion of Layer 1 blockchains, Layer 2 scaling solutions, ZK projects, and applications, the ecosystem remains woefully unprepared for mass adoption.

Imagine a future where:

All 8 billion people are onchain
Every asset is tokenized
Global stock markets settle onchain (10s of billions of shares daily)
Consumer-to-business transactions happen onchain (10s of billions per day)
All verifiable social media interactions occur onchain (10s of billions per day)

In this future, blockchains must process hundreds of thousands—if not millions—of transactions per second.

Beyond throughput, the shear data volume created via this activity and stored onchain will be staggering. Assuming (very conservatively) that each of these is the size of an average transaction on Ethereum (in the 200-300 byte range), we are talking about 100s of megabytes of data per second onto blockchains (on the low side).

And these are just conservative numbers, ignoring the possibilities of more complex data being used to drive more complex onchain actions.

While the many focus on building for scalability, the greatest barrier that remains is privacy.

In even the simplest scenario of a customer buying from a business, both parties want to protect their transaction history and assets. Yet on most blockchains, each party must expose an address that reveals their entire transaction history and balance to the other. This transparency is fundamental to how most blockchains work. However, privacy matters for real-world applications. Businesses require privacy for their transactions, data, and business logic – this asymmetry of information is their competitive advantage. Similarly, users need privacy for their transactions, assets, and data, as any information can potentially be used against them. As our future becomes increasingly digitally connected and autonomous, sovereignty and control over one's data becomes crucial for maintaining personal freedom.

Therefore, privacy is not optional—it is a prerequisite for mass adoption. And without scalable privacy, to support the billions, blockchain will remain a niche technology.

What Does Scalable Privacy Need, and Why Proofbase?

Privacy requires:

Private computation on private data.
Private interactions between users.
Trust-minimized verifiable execution.

This is ZK’s moment.

Privacy of data and computation necessitates offchain execution. Proofs enable this mechanism by serving as the verifiable interaction between offchain and onchain processes. zkVMs have been designed specifically to facilitate this capability, and as we approach real-time proving, it will become more accessible than ever. However, blockchains were not built for proof verification, and the design of proof-based applications demands an infrastructure we currently lack.

The best way to illustrate this is to attempt building one of these applications today, using existing ZK tools and blockchain infrastructure.

We would begin by writing our program in Rust, compiling it using a zkVM toolchain, generating an executable, and producing a proof for a given input. Next, we would develop a smart contract to verify the proof, execute additional logic as needed, and manage the state (or the commitment to the state) of the application onchain.

This approach, however, presents three major challenges:

Onchain proof verification is extremely costly. At the time of writing, verifying a proof on Ethereum can cost between $8 and $15 per transaction. If an application generates proofs at the rate of user interaction (as most private applications would), annual overhead costs would quickly reach millions of dollars. Furthermore, the need to compress proofs for onchain digestibility adds latency and computational overhead, making verification even more expensive. Even on a rollup, where verification costs are significantly lower (around $0.10 to $0.25 per transaction), the minimum cost per interaction places a barrier to innovation.
The blockchain becomes the sequencer. If the application is stateful, it must either store the entire state onchain within a smart contract (which increases cost and complexity) or manage state offchain via proofs. The latter adds significant computational overhead to proof generation and constrains applications to strictly synchronous interactions, even in multi-user settings.
Multi-user stateful applications require offchain coordination and management, introducing trust and complexity. If multiple users interact with a shared state, that state must be maintained offchain, requiring additional trust assumptions and increasing architectural complexity.

The first challenge—verification cost—is well understood. Leading blockchains will never be able to match the pace of innovation in ZK and are unlikely to support high-performance, state-of-the-art proving systems while also handling uncompressed proofs. The widely accepted solution is to externalize proof verification offchain to amortize costs, either through proof aggregation or proof attestation.

While both solutions are useful, they are imperfect for stateful proof-based applications. Proof aggregation compresses multiple proofs into a single proof, but this will always introduce additional latency and computational overhead, making it unusable at scale for real-time applications. Proof attestation, on the other hand, relies on a decentralized, economically secure network of validators to verify and attest to proof validity. While this approach reduces latency and cost, it does not resolve the state and sequencing issues imposed by blockchains.

A Fundamentally Different Approach: Parallelized, Asynchronous Proofchains

Solving these challenges requires more than just reducing verification costs. A private, proof-based application operating at scale must allow users to:

Transact concurrently and independently.
Manage their own private state with private execution.
Interact with applications and other users asynchronously.

This represents a fundamentally different approach to state and execution management compared to synchronous blockchains like Ethereum.

To understand what this would look like in practice, we must rethink how applications interact with state.

Imagine a system where each user generates proofs over their private data, updating their private state in independent proofchains. No user would be able to access or modify another user’s state. These proofchains could progress at their own pace, with each proofchain being verifiable independently of any other proofchain’s state. Users would submit proofs directly to validators, extending their own proofchains.

Validators in this network would verify proofs and state proposals and respond with an approval attestation. Importantly, validators would not need to communicate with one another—each proofchain remains independent, and users are responsible for ensuring that all validators receive their proofs to finalize state updates.

Finalization occurs when a supermajority of validators attests to the validity of the proof and the state. This strict state isolation creates a system where there is no global state and no need for consensus, eliminating the coordination bottlenecks that currently slow blockchains down and limit scalability.

In this network, adding more chains (users and applications) simply requires increasing validator hardware capacity. The speed at which any chain progresses is determined only by network latency (the speed of light) and proof verification time, which today operates in the range of hundreds of milliseconds.

An Actor-Based Model for Scalable Computation

This sharded, asynchronous network closely resembles an actor model of computation, where each user instance of a proof-based application acts as an independent actor. These actors are the fundamental building blocks of concurrent computation, fully generalized to support any provable application.

In this model, interactions between actors occur asynchronously via message passing. When one user interacts with another, they send a message—which may be an output of a proof (and therefore verifiable). As actors are independent, the receiving actor processes messages according to their internal logic and at their own pace, without impacting the progression of the sending proofchain.

This model provides natural parallelism, as state isolation guarantees ensure actors operate independently without interfering with each other. As a result, these systems are inherently scalable.

For interactive applications—where users maintain private data but also interact with shared application logic—this model enables trust-minimized interactions. User proofchains operate independently, while application proofchains handle coordination, allowing the blockchain itself to serve as the MPC protocol.

By structuring computation this way, the complexity of application development is significantly reduced. Developers can reason about actors in isolation, eliminating concerns about external interference and complications arising from shared state. This leads to simpler, more maintainable, and less error-prone applications.

Making Proofs First-Class Citizens of the Network

Addressing verification cost requires making proofs first-class citizens of this new network. In this model, proofs function as cryptographic signatures for actor-based proofchains.

By moving proof verification outside of execution, validators can independently verify proofs offchain, client-side. Since network costs for storage and computation remain independent of global network activity, transaction costs remain low and predictable.

A New Blockchain Layer for Stateful Verification

Naturally, this approach requires an entirely new blockchain layer. While this introduces potential friction and fragmentation, it is a limitation that can be abstracted away.

One of the key features of this architecture is that validator attestations themselves become verifiable cryptographic certificates of proof and state finality. These proof certificates are externally verifiable, provided the current validator set’s public keys are available.

If the validator set is established externally using EigenLayer, these proof certificates are natively verifiable on Ethereum. In this way, the system operates in parallel with Ethereum, serving as a stateful verification layer for proof-based applications.

This approach enables Ethereum-based contracts and assets to integrate seamlessly with proof-based applications, offering low-latency, low-cost verification for private applications at scale.

This is Proofbase—a stateful verification layer built to enable scalable, private applications.

The Problem with zkVMs and Why Lurk

Now that we have a network layer capable of providing both the infrastructure and programming model to support applications of this nature, we must ask: Do we have the proper ZK tooling to support it? Unfortunately, just as these applications impose requirements on infrastructure, they also impose requirements on the language and zkVM itself.

Simply put, applications of this type require language-level support for the primitives that define how applications interact with privacy in this network model.

The requirements for such a system largely fall into three categories:

Application verifiability and functional privacy – Applications must be verifiable from source to instance and linked to a proof. This ensures that individuals can verify the authenticity of a program and confirm that the version they are running or interacting with is derived from a source. Additionally, there must be a mechanism for users to interact with applications while keeping the source private, all while maintaining the ability to identify applications, verify functionality, and build trust.
Data verifiability and functional privacy – Both user state and program I/O must be verifiable, private, and well-defined. This extends from local user execution and state management to handling proof and program I/O and messaging between actors with self-describing semantic clarity.
Verifier deployment – The need for per-program verifiers, as is standard with zkVMs, creates deployment friction and limits scalability. Validators would need to maintain an ever-growing catalog of program verifiers, which burdens the autonomy of actors in spawning new applications and instances.

A Well-Defined Data Language for Private Concurrent Execution

In a concurrent execution model, where functions—or even entire programs—operate over private data, there must be a well-defined data language to provide syntactic clarity to program I/O. The most straightforward approach to solving these issues is through content-addressed commitments.

By content-addressing data via commitments, and requiring each evaluation step to open inputs and commit to outputs, we ensure immutability and fine-grained, selective data privacy in constant-sized I/O.

Since proof I/O contributes to proving and verification costs, a content-addressed data language minimizes I/O size, reducing overall computational costs while enabling proof statements over large datasets.

Further, structuring data with type information, much like JSON, allows explicit tagging of I/O intent and handling—both within program steps and across asynchronous actor messaging.

Structuring Code as Content-Addressed Data: Unlocking Verifiability and Privacy

Extending this strategy to code itself provides the same properties for programs. During prover compilation, the source code can be content-addressed, allowing the proof to be linked to both the program instance and the original source.

However, how one structurally hashes applications presents new design possibilities. Programs written in functional languages can be represented as abstract trees of evaluation paths, where each block of the program interacts with others in well-defined ways. This abstract syntax tree can then be transformed into a content-addressed representation via structural hashing.

Structuring programs in this manner ensures immutability and verifiability, not just at the program level but also at the granular level of code execution. Additionally, this leads to naturally scalable concurrent models of evaluation, where programs are referenced by constant-sized commitments and can be evaluated over private data.

Functional Commitments and Stateful Applications

Describing provable code via its commitment allows applications to bind behavior to a specific source while proving functional properties. These functional commitments extend seamlessly into stateful applications by maintaining a commitment to state as I/O, chaining together states via proofs.

This approach reduces stateful programs of any complexity into chains of constant-sized commitments. As a result, these functional commitments begin to resemble proofchains, creating natural structural synergies between program execution and network topology.

Code as Data: A Powerful Architectural Shift

Structuring and hashing code in the same manner as data unlocks deep and novel capabilities.

Programs themselves can output new code, enabling the spawning of new actors with new functionality.
Messages can transmit not only data but also update the receiving actor’s program.
Only the small content-addressed commitment is required for proof verification, ensuring fine-grained control over data storage, privacy, and access controls—even for large-scale distributed applications.

Eliminating Deployment Barriers: A Universal Proof Verifier

As a final step, by ensuring both program and I/O remain constant-sized—regardless of program complexity or input size—we can standardize the verifier to a single universal verifier capable of handling all programs from this VM.

This evolution shifts the zkVM from a traditional virtual machine into a verifiable operating system, capable of running any provable program across a distributed system.

Beyond Blockchain: Expanding the Model to Trust-Minimized Infrastructure

It is crucial to recognize that this language definition and programming model are not exclusive to blockchain applications. Instead, this approach can extend to running privacy-preserving applications in trust-minimized environments across various infrastructures.

For these reasons this language stack is valuable far beyond blockchain, opening up possibilities in confidential computing, secure multiparty computation (MPC), and privacy-first distributed applications.

This is Lurk.

Lurk is its own language and virtual machine, but that does not mean it is the only way it can be implemented.

Lurk can also be integrated as a package or library, allowing existing zkVMs to adopt this programming model, extending its benefits across multiple environments.

Our Pathway to Bringing the Future Forward

It is clear that this synergetic pair—Lurk and Proofbase—makes mass adoption-scale, proof-based applications possible. And not just for blockchain-based use cases, but for any application requiring verifiable trust.

Lurk provides the language-level tools to define these applications, functioning both as a standalone language and VM stack and as a set of packages and libraries that allow all zkVMs to build these applications.
By targeting JavaScript equivalence, Lurk can onboard the largest developer base in the world into the ecosystem of verifiable trust and permissionless finance provided by blockchains.
But it doesn’t stop there—Lurk can be ported to other functional languages, expanding its reach into diverse developer ecosystems and uses.
Proofbase enables complex, sensitive, and private applications to be built across multiple blockchains, making mass adoption-scale applications a reality.

This is the vision. But how do we get there? How do we buy ourselves the time to see it through and build durability along the way?

The Current State of the Market

At present, there is little market demand for proof-based applications. Over the past few years, ZK has evolved—transitioning from a critical scaling solution to an application-level infrastructure as the technology matures. However, in many ways, ZK is still searching for its application-level product-market fit.

We have seen promising successes:

Private payments, with Zcash enabling anonymous and private transactions at scale.
Identity verification, with Worldcoin generating over 9 million proofs of humanity.
UX innovation, with Sui’s zkLogin simplifying blockchain access, generating millions of proofs.

While these developments demonstrate the promises of ZK, the breakthrough applications—the ones that will drive mainstream adoption—have yet to emerge. This is not due to a lack of ideas, but rather a lack of capable tools and infrastructure.

Unlocking New Markets with Lurk and Proofbase

Our stack opens an entirely new world of possibilities.

Institutions and enterprises requiring privacy for data and business logic can now deploy infrastructure on blockchain without relying on trusted intermediaries.
Regulatory compliance can be cryptographically verified, eliminating the need to reveal sensitive data and reducing the overhead of audits and reporting.
User compliance verification can be done without exposing personal data—enabling businesses to serve global users securely and with reduced risk.
Multi-party compliance systems and automated business logic can execute with verifiable trust, removing layers of middlemen and allowing users greater autonomy at lower costs.
Businesses can engage directly with users, increasing efficiency and profitability.
Verifiability then becomes the core mechanism by which AI agents interact with the world.

Identifying unique use cases for our stack is relatively easy. However, these new markets and paradigms will take years to develop, requiring both technological advancements and strong industry relationships. While this remains our long-term vision, we must focus on today’s users to establish a foundation for the future.

Who Are Our Users Today?

As mentioned earlier, few developers are actively building with ZK today. Adoption is growing each year, but ZK does not yet constitute a well-defined market.

However, the market for ZK is essentially the market for blockchain applications—therefore blockchain application developers are our primary users. ZK is simply a tool to enable new functionalities with better UX.

Thus, our target market is not just “ZK developers”—it is the broader blockchain development ecosystem. And crypto-native users are our early adopters.

Building for Crypto-Native Users: The Path to Mainstream ZK Adoption

By focusing on crypto-native users, we make ZK application development mainstream.

Instead of a visionary message of "ZK is the future," the message becomes tangible by what it provides: "This is the best way to build applications on blockchain."
By pushing ZK into the background, we onboard developers who care about building great applications—not those who need to understand the technical complexities of proofs.
In doing so, we lay the groundwork for the next generation of applications.

What kind of applications will crypto-native users create?

Games
NFTs
DeFi protocols
Applications steeped in internet-native culture

These are the applications that crypto-native users love.

The Flywheel Effect: Community, Applications, and Innovation

By focusing on community-first, application-first, and product-first development, we transform the blockchain experience through innovative applications—inspiring others to build the next generation of tools and products.

By providing a simple, intuitive platform, we create a flywheel effect:

A strong community emerges.
That community drives innovation.
Innovation produces amazing applications.
Great applications attract more users.
A growing user base fuels further community engagement.
The cycle repeats.

But, this is not something we can leave to hope.

While we have minimized barriers to entry, we still require developers to learn something new, take risks, and experiment with innovation. So we will build alongside them—with them, for them.

They are helping to bring the future forward, whether they realize it or not.

Establishing a Rich Ecosystem: The Foundation for Institutional Adoption

Through this process, we establish a thriving ecosystem of new, groundbreaking applications.

This buys us the time to refine our infrastructure.
It allows us to collaborate with institutions to bring large-scale innovation onto the blockchain.
It ensures that privacy for data and code is integrated from the start, grandfathering freedom into the beginning of this technological revolution.

This is how we steer the adoption of blockchain and the AI revolution down the right path for us all.

This Is How We Change the Future—And Make It Freer Than It Is Today.

By prioritizing developer experience, real-world adoption, and trustless privacy, we set the foundation for the next era of blockchain applications.

The future of high-performance privacy is within reach—and we are building the tools to make it a reality.

This is how we bring the future forward.