Introduction

Three weeks ago, we launched the Pi Squared VSL devnet, our first public proving ground for verifiable, decentralized execution.

It was a big moment for us. We opened up our core infrastructure to developers, researchers, and partners and invited them to test-drive the ideas behind the VSL: programmable claims, composable compute, and on-chain verifiability across systems. And what followed was even better than we expected.

Over the course of the devnet, we saw real usage, strong engagement, and a wave of interest from across the ecosystem. Demos ran continuously. Millions of claims were processed. Developers explored, built, and gave feedback that helped shape what is to come.

Now, as we wrap up the devnet, we want to take a moment to look back at what we built, what we learned, and where we're headed next.

What we built together

The goal of the devnet was simple: to put the Verifiable Settlement Layer (VSL) into the hands of real developers and see what they could do with it. Over the course of two weeks, we saw that goal come to life.

We launched with a set of public demos that highlighted some of the core use cases for VSL: multichain asset transfers, blockchain mirroring, and AI running inside trusted execution environments (TEEs). In total, seven demos ran continuously throughout the devnet. These weren't just technical showcases. They were live, interactive examples of how programmable claims could power new types of infrastructure across domains.

More importantly, we saw developers explore and test the limits of what's possible. From debugging flows to poking at edge cases, this wasn't a passive experience. It was active, hands-on participation in building a better foundation for verifiable computing.

Devnet by the numbers

Beyond the demos and developer feedback, the devnet gave us something even more valuable: real-world data.

Over the two-week period, more than 71,000 people signed up to explore the devnet. From that group, we allowlisted over 3,500 wallets to access the live demos, ensuring a steady wave of real developers actively testing and interacting with the VSL-powered applications in a focused, hands-on environment.

Behind the scenes, our infrastructure was doing exactly what it was built for. Across seven live demos, the network processed over 2 million claims, with most of them settled explicitly by users signing transactions in their wallets. That translates to more than one claim per second, settled through real, hands-on interaction.

These numbers gave us confidence not just in the technology, but in the growing interest around verifiable infrastructure too. Developers are ready for faster, more flexible systems. And the VSL is helping prove what that can look like.

What did we learn?

One of the biggest benefits of running a public devnet is that it reveals things you can't always catch in a controlled environment. The past two weeks gave us a clearer picture of how VSL behaves under load, how developers interact with it, and where the experience can be improved.

We saw which demos attracted the most attention, where developers got stuck, and which features sparked curiosity. The multichain and mirroring flows generated steady engagement, and the AI + TEE demo opened up new conversations around composability and trust in AI systems.

The feedback we received from Discord chats to direct integrations helped us uncover usability gaps, surface feature requests, and refine how we talk about VSL. It also confirmed something important: the core ideas behind VSL resonate. Developers are thinking about claims as primitives, not just proofs. They're imagining new workflows, not just porting old ones.

The devnet validated the direction we're heading to and gave us a better sense of how to move forward.

Where we’re headed: FastSet

With the devnet wrapped up, we're now turning our focus to what's next.

Introducing FastSet, the next evolution of our verifiability stack.

FastSet builds on everything we learned from the devnet. It's designed to handle claims at a much larger scale by introducing parallel claim settlement without consensus. This means claims can be validated and finalized without needing complex validator coordination, making the system faster, leaner, and more scalable from day one.

If VSL was about proving that programmable claims could work across systems, FastSet is about pushing that to a production-level scale.

We'll be sharing a lot more about FastSet over the coming weeks, but for now, you can get a deeper look at how it works by checking out the FastSet whitepaper. We're excited about what this unlocks, and we're just getting started.

Stay involved

To everyone who joined the Devnet, we want to say thank you.

Whether you explored a demo, tested edge cases, submitted feedback, or just watched from the sidelines, you helped us move this technology forward. We're grateful for the energy, ideas, and curiosity you brought to the devnet.

The devnet is now closed, but this isn't the end; rather, it marks the beginning of something new.

We're now shifting our efforts to FastSet, and we'd love for you to be part of that journey, too.

Here’s how you can stay involved:

• Read the FastSet whitepaper to learn more about the next phase of our infrastructure.
• Join our Discord to stay connected and share ideas.
• Follow Pi Squared on X for weekly updates, technical drops, and news on what's coming next.

Thanks again for helping us get here. Let's keep building!