New Verification Methods Aim to Replace Trust With Proof in Computing Outputs

Every time a computer produces an output, it raises a basic question: did the machine actually execute the intended program correctly, on the stated inputs, to arrive at that result? In most settings today, the answer depends on trust layered with after-the-fact verification. We trust a cloud operator, a software vendor, a counterparty, or an automated agent, and then lean on contracts, audits, access logs, and compliance processes to reduce the risk that something went wrong—or was misrepresented.

Zero-knowledge proofs (ZKPs) propose a different foundation. Instead of relying primarily on who ran the computation, ZKPs make it possible to rely on what the computation produces alongside its output: a compact cryptographic proof that the program was executed as claimed. The proof functions as a certificate tying a specific program and specific inputs to a specific output. Crucially, it is designed to be tiny and quick to validate—often checkable in milliseconds—so recipients can confirm correctness without re-running the work themselves. And because the proof can be “zero-knowledge,” it can provide that assurance without exposing sensitive inputs that should remain private.

If generating such proofs became as routine as running software, it would change the meaning of correctness in real-world systems. An AI agent acting on a user’s behalf could attach a proof that each step it took adhered to the policies it was given. Financial institutions operating under strict regulation could demonstrate that transactions were processed properly while keeping the underlying details confidential. In this model, trust shifts away from institutional reputation and toward portable, cryptographic evidence that can be forwarded and independently verified by anyone who needs the same guarantee.

The concept is not new. Zero-knowledge proofs date to the 1980s, and the broader idea of proving correct program execution has been studied for decades. What has prevented the technology from becoming a general-purpose tool is that three requirements have been difficult to satisfy at once: performance, generality with developer-friendly workflows, and long-term cryptographic assurance.

First is efficiency. Historically, producing a proof could cost millions of times more computation than simply running the program. While years of research have reduced this overhead substantially, many of the fastest approaches have reached their speed by trading away other desirable properties.

Second is generality and usability. In many ZKP systems, developers must translate their application logic into a specialized “circuit”—an arithmetic representation of the computation tailored to that exact program. That translation can take months, must be repeated whenever the program changes, and is itself a frequent source of subtle security flaws. A more flexible alternative is to prove the execution of a standard processor, allowing ordinary compiled code to be proven directly. But until recently, that kind of general-purpose proving typically imposed major penalties in speed or security.

Third is security—particularly in a world preparing for quantum computing. Many widely used proof systems depend on elliptic-curve cryptography, which could be broken by a sufficiently capable quantum computer. Microsoft has highlighted this risk through its Quantum Safe Program, under which it plans to migrate products and services to post-quantum cryptography, a timeline the company has recently accelerated to 2029. Post-quantum proof systems exist, but many rely on lattice-based assumptions, and many also introduce newer cryptographic functions aimed at cutting proving costs. Those functions have not benefited from the decades of analysis that underpin much of today’s internet security, and some depend on unproven conjectures related to error-correcting codes—meaning performance gains can come with stronger, less time-tested assumptions.

Against that backdrop, Microsoft Research has spent more than a decade working to make verifiable computing practical. Early efforts pursued two avenues that were workable only for relatively small programs. One used interactive methods—where a verifier checks a long computation via a short back-and-forth exchange with the prover—building on techniques such as the sum-check protocol, but only for computations with specific layered structures. Another line of work relied on elliptic-curve cryptography to obtain very small proofs, but inheriting the quantum vulnerability of those foundations.

Why it matters

As software agents and outsourced computation take on more decision-making, organizations need ways to verify outcomes without blindly trusting the party doing the work. Proof-based computing could make compliance, auditing, and cross-organization collaboration faster and more privacy-preserving by turning correctness into something that can be cryptographically checked. The next key question is whether new systems can deliver speed, general-purpose programmability, and post-quantum security without relying on assumptions that are too new—or too brittle—to bet critical infrastructure on.