← PortfolioReasoning and trust

Logical Intelligence

Energy-based AI models for formal verification

Team
Eve BodniaCEO
Vladislav IsenbaevCRO
Founded
2025
Invested
2025
The problem

How do you prove a program works without an army of mathematicians?

Press on any step of the trace and drag it off the valley floor. Let go, and the whole trace slides back downhill at once before Lean checks it.A reasoning trace laid across an energy landscape, where the valley floor is where every step fits. The model scores the trace while it is still being written and points at the step that broke a constraint. Then it nudges every step downhill at once, instead of rewriting everything after the mistake, and Lean's checker has the final say.An illustration, not real data.
How proving code works

Testing a program shows it behaves on the cases you tried. goes further: it proves, with mathematics, that a system is correct with respect to a formal specification. Every such setup has three parts. The spec says what the program may and must never do, the code is the program itself, and the proof is an argument that the code meets the spec. A checker then decides whether the proof holds.

There are two broad ways to get that proof. Fully automated methods like model checking and static analysis work on limited systems and properties. Interactive proof handles much more, but it needs people doing the work by hand, step by step, inside a tool called a .

An is a different kind of AI from the chatbots most people know. Rather than writing out an answer word by word, it gives every candidate answer a single number, its energy: low for answers that fit, high for ones that don't. Finding an answer then looks like a hiker walking downhill to find the valley floor.

Further reading Formal verification (Wikipedia)Automatic Formal Verification for Code Generation (Logical Intelligence)Frequently Asked Questions on seL4 (seL4 Foundation)I-JEPA: The first AI model based on Yann LeCun's vision for more human-like AI (Meta AI)Proof assistant (Wikipedia)Energy-Based Models for Reasoning, LLMs for the Interface (Logical Intelligence)

Why it is hard
  1. i.

    No universal checker

    There is a ceiling built into computer science. Rice's theorem says every non-trivial question about what a program does, such as whether it finishes on every input, is . No single tool can answer those questions for all programs. So verification tools either narrow the question or on someone to supply the proof.

  2. ii.

    Proofs outweigh code

    The best-known verified operating system kernel, seL4, started out at roughly 8,700 lines of C. Its proof ran to about 200,000 lines, and the proof base has since grown past a million. Writing the spec and most of the proof by hand is expensive enough that formal verification has only made sense in a few places, like core cloud infrastructure.

  3. iii.

    One token at a time

    The obvious fix is to let a language model write the proofs. But language models generate text by token, so revising an early step usually means regenerating everything after it. They are trained to predict the next token, which is not the same as getting a long chain of reasoning right from end to end. A proof is exactly such a chain.

Further reading Rice's theorem (Wikipedia)seL4 explained, the 10,000-line kernel with a million lines of proof (Webiano)Automatic Formal Verification for Code Generation (Logical Intelligence)Energy-Based Models for Reasoning, LLMs for the Interface (Logical Intelligence)

What Logical Intelligence is after

Logical Intelligence builds AI tools that automatically generate machine-checkable proofs of safety and correctness for critical systems. With AI writing more and more of the world's code, the company's view is that "ship it and fix it later" no longer holds, and that proof has to become cheap enough to use by default.

Further reading Logical Intelligence's Aleph Solves PutnamBench (Logical Intelligence)Automatic Formal Verification for Code Generation (Logical Intelligence)

How they go at it
  1. Step 1: Score the whole attempt

    Kona, the company's energy-based reasoning model, puts a score on reasoning traces, including half-finished ones. That matters because a score on a partial trace can point at which step broke a constraint, rather than just reporting failure at the end. Kona also works on the whole trace at once, in a continuous , so it can nudge any part of it towards lower energy.

  2. Step 2: Language at the edges

    Language models still have a job. They are good at turning fuzzy human requirements into rough formal structure and explaining failures. The bet is that the hard middle, keeping spec, code and proof consistent with each other, suits an energy model, whose learned energy acts as a cheap but imperfect verifier.

  3. Step 3: Let Lean decide

    Aleph, the orchestration layer, coordinates calls to Kona, language models and other tools. Its proofs are written in Lean and certified by Lean's own deterministic checker, so a wrong answer can't sneak through. On PutnamBench, a set of 672 hard competition maths problems, Aleph generated proofs for 668.

Further reading Energy-Based Models for Reasoning, LLMs for the Interface (Logical Intelligence)Automatic Formal Verification for Code Generation (Logical Intelligence)Logical Intelligence's Aleph Solves PutnamBench (Logical Intelligence)

Still open
  • Does the spec say what you meant?

    A proof shows the code matches its formal specification, not necessarily what a person intended. The more ambitious setups have AI write the spec too, starting from a plain-language description, which moves the question of intent rather than settling it.

  • Who checks the checker?

    Proof checkers can be small, some with under a thousand lines of core code, which makes them checkable in turn. They are not flawless: a claimed disproof of the Collatz conjecture was announced as verified in Lean, then found to rely on a bug in Lean itself.

  • How do you train an energy model well?

    In the textbook version, turning energies into probabilities needs a normalising constant over every possible input, which cannot easily be computed during training. It gets approximated by sampling instead, and how to make that cheap at scale is still being worked out.

Further reading Automatic Formal Verification for Code Generation (Logical Intelligence)Proof assistant (Wikipedia)Lean (proof assistant) (Wikipedia)Energy-based model (Wikipedia)

About Logical Intelligence

Logical Intelligence is a fundamental AI research organization that uses new techniques in reasoning to make theorem-provers capable of verifying large computer programs. Their early commercial traction is in the crypto space, where billions of dollars might be at stake for software errors.

The company uses a process called "formal verification" and has developed a model that allows an AI agent called Aleph to convert code into mathematical proofs that can be verified to 100% accuracy. The team includes a Fields Medal winner and programming world champion.

Words used here
Formal verification
Using mathematical proof, checked by a computer, to show a system does exactly what its specification says.
proof assistant
Software that helps a person build a formal proof and checks every step of it.
energy-based model
An AI model that scores how well a candidate answer fits, with low scores meaning a better fit.
undecidable
Impossible for any algorithm to answer correctly in every case.
token
A small chunk of text, often part of a word, that a language model reads and writes one at a time.
latent space
The internal numerical space where a model represents problems, rather than as words.
Lean
A proof assistant and programming language whose checker certifies that a proof is correct.
Sources