Production Ready Private Proof Delegation is Here.

In April, we released the beta version of TACEO:Proof: a proving network that enables zero-knowledge applications to delegate proof generation to a secure, privacy-preserving compute network. Built on multiparty computation (MPC) and collaborative SNARKs (coSNARKs), the beta demonstrated that proving can be private, performant, and seamless even for constrained clients.

Since then, developers generated more than one million proofs across a range of circuits. The system operated without failure, validating the underlying architecture and exceeding performance expectations.

Today, TACEO:Proof moves out of beta and into production.

TACEO:Proof is the first production-grade private proof market, designed to deliver cryptographically private, fast, and verifiable proofs at scale.

Why This Problem Matters

In crypto, UX is often treated as a second-class concern. That’s especially true in zero-knowledge systems. While the underlying cryptography has advanced dramatically in recent years, client-side proving still suffers from fundamental issues:

• Long proving times that frustrates and confuses users, especially on mobile
• Large app sizes due to embedded proving libraries up to often hundreds of megabytes
• Frequent crashes or memory limitations, particularly on lower-end devices

It’s not uncommon for mobile apps attempting ZK operations to either freeze or require massive downloads before anything meaningful can happen.

TACEO:Proof changes this.

By allowing developers to delegate proof generation to a private, trust-minimized network, we remove these constraints while preserving zero-knowledge guarantees. The result is a step-function improvement in user experience, with almost no integration burden.

What’s New Since Beta

The beta launch laid the foundation. But the production network introduces real advances, both for developers building on TACEO:Proof and for those running the infrastructure itself.

Broader Benchmarks

There’s been some healthy skepticism about whether delegated proving through MPC can really outperform local proving as it involves multiple rounds of communication, both between the client and the network, and among the MPC nodes themselves.

Though we’ve published proving times in the past, one of the most common questions we get around benchmarks is about the full end-to-end cost. For the first time, we’re publishing end-to-end performance benchmarks—measuring the time it takes from when the client secret-shares, encrypts, and uploads the witness to the network, all the way to when the proof is downloaded. We compare:

• TACEO:Proof (delegated proving on MPC network)
• User-grade hardware (Framework 13)
• Mobile devices (Samsung Galaxy S23+)

Performance comparison across different circuits and platforms (measured in seconds):

Note: Times on phone and laptop don’t include downloading the zkey or witness. Times on TACEO:Proof are with proof only and using REP3 and with cached job data.

The performance benefits are clear across all circuit types, with TACEO:Proof consistently delivering faster proving times than local computation, while maintaining privacy. Integration, meanwhile, takes fewer than 10 lines of code.

Batch Proving. We noticed some developers have situations where a piece of work requires several proofs. In this case, TACEO:Proof can really shine relative to client-side proving. We tested batch proving and found that for chacha20 we can generate 30 proofs under 5 seconds, and for RSA 30 proofs under 30 seconds. This represents a significant advantage over sequential client-side proving, where generating 30 proofs would take considerably longer and potentially overwhelm mobile devices.

Developer Experience - Dashboard and Monitoring

Alongside performance, we’ve focused on making the network easier to use. Application developers now have access to a new dashboard that includes:

• Circuit management: Upload, revoke, or update circuits via a visual interface
• Monitoring tools: Track delegated proof requests in real-time
• Event logs: Easily debug failures and view system-level metrics

This makes proof management much easier than relying purely on CLI-only or SDK-wrapped workflows.

Here, Lukas gives us a walkthrough of uploading a circuit, getting a blueprint, running jobs, and getting and verifying a proof.

Decentralisation and Node Providers

The beta network was run primarily on TACEO-owned infrastructure to allow for quick troubleshooting and updates. While preparing to move to production, we onboarded a number of independent node providers to ensure that no single participant can access private data.

Cloud-Agnostic and Bare Metal Ready

In the beginning, we required node providers to use AWS EC2 to simplify setup. That limitation is gone.

Now, nodes can run on any infrastructure: cloud providers or on bare-metal machines. This opens the door to more diverse hosting setups and reduces reliance on any single provider.

What’s Next

Though TACEO:Proof moves into production, we continue to work on strengthening the network and supporting the community. The next steps are already in motion.

• Decentralisation: We aim to onboard more independent nodes to increase geographic and jurisdictional diversity.
• Language support: Support for Noir and the UltraHonk backend is underway, opening the network to (in our opinion) the most promising group of developers working with ZK tooling.
• Stronger trust assumptions: We’re currently experimenting with running MPC nodes in Trusted Execution Environments (TEEs) to ensure not only cryptographic integrity, but also hardware-level isolation.
• Performance improvements: The TACEO:Proof network is the first step in a bigger picture. We’re working on performance improvements to make witness extension on the network more attractive, extending proving to private shared state.

More details will follow on each of these areas.

Final Thoughts

The beta proved the concept. The production launch addresses the problem. With TACEO:Proof now live, developers can integrate fast, private proof generation without rethinking their stack or asking users to wait 20 seconds on their phones. Nodes can operate independently, without access to sensitive data.

If you’re building ZK-based applications, or want to run a node, don’t hesitate to reach out.

If you’re generally interested ZK and want to explore coSNARKs further, join us on Discord, follow our updates on X, or subscribe to our newsletter.