Theorem: The AI Startup That Verifies Code 10,000x Faster

In today’s world, software infrastructure underpins everything from global financial systems to critical healthcare applications. As this infrastructure becomes increasingly reliant on AI-generated code, it simultaneously becomes more vulnerable. Bugs, misconfigurations, and overlooked security gaps can become gateways for attackers — especially in mission-critical environments like cryptography or GPU-accelerated computation.

Theorem was born from a simple but urgent question: What happens when the pace of AI-generated code outstrips our ability to verify and trust it? Founded in 2025 and backed by Y Combinator’s Spring batch, this San Francisco-based startup seeks to solve one of the most pressing challenges in computer science — how to ensure that software is not only performant but provably correct and secure.

While AI-generated code can save time, it introduces new risks. Human code review can’t keep up with the scale and complexity of modern systems. That’s where Theorem steps in — not just with another coding assistant, but with a fundamental shift in how trustworthy software is built.

Why Is Formal Verification the Missing Link?

Formal verification — the process of mathematically proving the correctness of a program — has long been the gold standard for mission-critical code. But historically, it’s been slow, expensive, and reserved for elite applications. For example, the code generator powering secure HTTPS connections in Chrome took over fifteen man-years to develop.

This immense cost has made formal verification impractical for most developers. Until now.

Theorem is applying AI to dramatically accelerate this process, making program verification up to 10,000 times faster. What was once a PhD-level exercise requiring years of work can now be handled in hours. In one notable case, Theorem’s models uncovered a zero-day vulnerability in legacy HTTPS code from 2011, in just two hours.

Formal verification is no longer an unattainable luxury. Theorem is making it a practical reality for the mainstream developer community.

How Does Theorem's Approach Work?

At the heart of Theorem’s innovation is a new paradigm: trustworthy-by-default programming. Rather than building software and hoping it works as intended, developers use Theorem’s system to ensure correctness from the very beginning.

The startup’s most promising methodology is called program equivalence-driven development. The idea is simple but powerful:

• Developers write a simple reference implementation of a program — one that’s easy to understand and verify.
• Theorem’s AI then generates a high-performance version of that program.
• Alongside the optimized code, Theorem provides a formal proof that both versions are functionally identical.

This ensures not only that the optimized code works, but that it works exactly as intended.

The result? Secure, fast, and reliable software development that scales with modern demands.

What Use Cases Is Theorem Enabling?

While Theorem is still in beta, early customers are already seeing results across several high-stakes domains:

• Performance Optimization: Hyper-optimized GPU code is notoriously hard to get right. Theorem helps developers identify failure points and generate safer, faster alternatives.
• Code Migration: Moving from one language to another — say Python to Rust — is often fraught with bugs and regressions. Theorem not only automates the translation but also proves there’s no change in functionality.
• Security Auditing: AI-accelerated verification helps spot vulnerabilities in cryptographic systems and legacy infrastructure that would otherwise go unnoticed.
• Documentation & Dependency Management: Theorem clarifies obscure interactions between components, surfacing hidden dependencies that can introduce unpredictable behavior.

These examples underscore the versatility of Theorem’s approach. Whether a company is upgrading legacy systems or fine-tuning machine-learning pipelines, Theorem offers a way to do so with mathematical confidence.

Who Are the Minds Behind Theorem?

Theorem was co-founded by Jason Gross and Rajashree Agrawal, two visionaries combining deep technical expertise with ambitious, forward-looking ideas.

Jason is no stranger to building secure, performant code. He previously contributed to a project that powers trillions of HTTPS connections in Chrome and other browsers — one of the most widely used pieces of infrastructure on the planet.

Rajashree brings a different kind of intuition to the table, focused on model development and human-computer interaction. Together, they embody the fusion of systems engineering, programming languages, and AI — the very disciplines Theorem sits at the intersection of.

Their team may be small — just two people at the moment — but their vision is expansive. They’re building not just a company, but a research lab exploring the limits of verifiable AI coding.

Why Does This Matter Right Now?

Software systems are growing in complexity. At the same time, attackers are becoming more sophisticated, and AI will soon enable them to operate at unprecedented speed and scale.

That means bugs aren’t just technical issues; they’re security liabilities.

Traditional human review processes can’t keep up. Meanwhile, AI-generated code adds another layer of uncertainty. Without knowing how a model generalizes, it’s dangerous to trust its outputs in critical systems.

Theorem offers a compelling solution: use AI to constrain AI.

By wrapping code generation in formal methods and verification, Theorem brings oversight and trust back into the software development lifecycle. This is the only way we’ll be able to deploy AI-generated code at scale — without opening the floodgates to vulnerabilities.

What’s Next for Theorem?

Theorem is currently in beta and gradually rolling out its tools and programming environment. Developers working with mission-critical systems — especially those needing performance, correctness, or migration support — can already apply to join the beta and start integrating these tools.

As they scale, Theorem is poised to become a cornerstone of secure, AI-enabled development. Just as GitHub Copilot redefined productivity, Theorem could redefine trust.

Their goal is bold but clear: make code generation not only fast and scalable but also provably correct by design.

How Will Theorem Impact the Future of AI and Software?

The implications of Theorem’s work go far beyond debugging and optimization. This is about creating a new relationship between humans, AI, and code.

• For developers, it means focusing on intent and correctness, not memorizing syntax or tracking edge cases.
• For companies, it means deploying software that’s faster, safer, and easier to maintain.
• For the broader tech ecosystem, it means restoring confidence in the systems that increasingly run our lives.

If Theorem succeeds, the term “trustworthy software” may stop being an aspiration and become a default.