Verifiable AI

Prove the work.
Backed by math.

For AI to go well, we need to verify what happens inside AI datacenters.

Each AI answer comes with a mathematical proof of how it was computed. Anyone can check that proof without trusting the company that runs the AI.

Working today on a small test model: every answer gets a proof, and a separate computer checks it. Lucid still runs every part, and no outside group has reviewed it yet.

27–43×less proving time vs zkLLM

Historical single-layer comparison. Re-timing pending.

Benchmark details

Per layer and token position. Synthetic layer; newer GPUs; no weight hiding. Timed before a soundness fix. Re-timing pending.

  • Ours is not zero knowledge yet; zkLLM hides the weights
  • One synthetic layer vs a whole model
  • H100 or RTX 6000 Ada vs A100
  • zkLLM's time is a sum of per-operation times
  • Our proof is larger: for one layer (at 4,096 positions) vs for zkLLM's whole model
  • Ours by our own model, not externally reviewed; zkLLM states no bit level
  • One-time costs excluded on both sides

Ours: one Llama-8B-width layer over 2,048 positions, 0.220 ms per layer and token position on a rented H100, 0.354 ms on a rented RTX 6000 Ada (cold). zkLLM: its whole LLaMA-2-7B model on an A100, 9.46 ms per layer and token position (620 s ÷ (32 × 2,048)), and it hides the weights. One-time costs excluded on both sides.

9.46 ms ÷ 0.220 ms ≈ 43 (H100); 9.46 ms ÷ 0.354 ms ≈ 27 (RTX 6000 Ada, cold).

Our zero-knowledge path runs end to end, but its proofs are being re-checked after a verifier fix, and it is not faster than published systems. Our fast path is not yet zero knowledge.

No custom silicon

Proofs run on ordinary rented GPUs.

How it works

Deployed today

Real answers with checkable proofs. Claims are live and unreviewed.

Try it

Four questions for verifiable AI

01 Where · Are the chips?

Threat
Undeclared chips power a hidden datacenter.
Verify
The checker times fresh work to bound where it ran.

The basic idea

Think of a student showing how they reached an answer so someone else can check it. Here, the company running the AI servers would provide mathematical proofs for selected answers. A separate verifier checks those proofs against the model approved in advance. The aim is to check the calculation without taking the company’s word for it. Proposed timing and capacity checks would also help limit where the work ran and how much computing capacity could remain for other jobs.

Scroll to follow the highlighted equipment. Faded racks are background; open trays reveal parts normally hidden inside the servers.

The extra checks on location and computing capacity are proposed; earlier proofs are being re-checked.

Opened to show the insideInternal parts not shown
  1. Install the verifier’s locked cage

    To make an existing datacenter verifiable, the verifier puts its own equipment in a separate locked cage inside the operator’s hall. The capture rack holds a fibre tap, a recorder and an authorized TLS gateway. The checker rack holds the proof checker, an inventory database, a trusted timer and the verifier’s own switch. The yellow dots mark the single fibre cross-connect between the verifier’s switch and the operator’s network switch. The verifier controls the cage and decides who may open it.

    Anyone can check a proof anywhere, so checking proofs does not depend on this cage. Capture does. Proofs only cover requests that were recorded. If someone tampers with the tap or recorder, or routes traffic around them, gaps could appear. Seals on the cabinets and on the cables from tap to recorder, a camera and inspections by both parties make tampering visible. They do not prevent it. Proposed, not built.

    More

    Inspectors would record the seal numbers and photographs when the capture equipment is installed, then compare them and the camera record at each inspection. A broken seal, a gap in the camera record or an unexplained door opening means requests from that period may be missing from the record. Every route that carries covered traffic would need the same protection.

    These seals, the camera and the inspection routine are designed, not installed or qualified. A clean record cannot exclude every physical attack.

  2. List the operator’s servers and GPUs

    The operator runs the highlighted servers across the hall. The orange dots show it sending a list of its servers and GPUs over its management network. The list goes up each highlighted rack’s uplink, along the overhead cable trays and through one cross-connect to a database inside the verifier’s cage. It records which machines the operator says it runs. It is also the starting point for estimating their total computing capacity.

    The operator’s servers sit in the open hall. The verifier controls the separate checking cage. The declared list still needs independent checking for missing machines.

    More

    This illustration shows one operator-operated hall. The declaration covers its whole operator-controlled compute pool, not only the ten foreground serving racks. Verifier-controlled equipment is listed separately and is not credited as the operator’s computing capacity. The inventory must identify the machines, GPU models and counts, locations and applicable time interval. Filing this record is distinct from an independent physical inspection; completeness remains an assumption unless supported by further evidence. In a shared cloud or colocation site, the declaration must name the operator’s specific compute pool; other customers’ equipment is outside that pool.

    The capacity record names the GPU pool, the time interval and the computing rate used for each device. The checker’s accounting software stores capacity records in a database; these are records about the chips, not software installed on each chip. Today the capacity input is entered by hand, and no inspection establishes that every GPU has been listed. The proposed on-site checker is the rack shown here. A credible upper limit must include possible higher clock speeds. Work and capacity must describe the same machines, interval and arithmetic unit. The accounting unit is an integer multiply-accumulate operation: multiplying numbers and adding the results. The chart’s values are illustrative.

  3. Save the approved model’s fingerprint

    The CPU package and memory DIMMs shown here sit on the checker’s motherboard. Before the checker looks at any answers, it makes a digital fingerprint of the approved model and saves it. Later proofs must match this fingerprint. So the operator cannot pass a check by proving an answer from a different model.

    Motherboard reference

    This illustrative motherboard has CPU packages, memory DIMMs, a network module and local storage. The GPU baseboard is a separate assembly. Compare NVIDIA’s motherboard diagram.

    The cutaway hides covers and CPU heatsinks to expose the parts. Operating servers need their cooling hardware installed; this is not the exact Azure or Verda host.

    More

    A fingerprint is a cryptographic hash of the model weights—the numbers that define the model. Proofs are checked against the checker's own fingerprint; that it fingerprinted the real published checkpoint is a premise. The proof covers an integer version of the model. On 17 test sequences it picked the same next token as the released model of the time when both read the same text, and 3 of 17 free replies came out identical. That is no guarantee for other prompts. A verifier flaw found on 29 Sep is fixed (reviewed), and earlier proofs are being re-checked with the fixed verifier; until then they count .

  4. Record the questions and answers

    The optical tap copies encrypted traffic in both directions to the recorder. It cannot read HTTPS content. The authorized TLS gateway below it keeps its own record of questions, answers and model settings. It sends them over an encrypted link to the sealed log before anyone chooses which answers to check.

    Proposed capture system. A compromised gateway or an unmonitored route can leave gaps. A passive tap cannot block either.

    Capture and trust boundary

    Evidence for Prove: the authorized gateway records the question, answer, request identifier and agreed model settings. These records bind the selected exchange to the mathematical proof checked by the verifier.

    Application path: client HTTPS ends at the gateway; a new encrypted connection carries the request to the serving network. The gateway sends application records to the recorder over a separate encrypted connection.

    Optional TAP monitoring: the optical TAP sits on the external encrypted link, with one receive-only copy per direction sent to the recorder. It cannot decrypt HTTPS or establish complete application capture. See the manufacturer’s TAP cabling reference.

    Every covered route would need monitoring, including redundant links. Unmonitored routes and a compromised gateway remain gaps. This physical capture system is proposed; the live chat pilot does not establish it.

    More

    The verifier keeps the capture path and its signing keys under separate custody. Each entry seals the one before it, so an edit breaks every later seal. Today the log and its signed checkpoints stay inside the recorder: outside witnesses are built but not tested yet. Traffic that skips the recorder isn't covered.

  5. Choose an answer for a surprise check

    Next the verifier picks an answer from the saved record and asks the operator to prove it. The yellow dots show that request going through the operator’s network switch to the selected AI server. The choice comes after the answers are recorded. That makes it harder for the operator to give honest answers only where it expects a check. A small sample can still miss a single false answer.

    More

    The verifier supplies fresh random selection only after the recorder has sealed the batch.

    How soon a cheater is caught, 99 times in 100
    Answers provenFake answers it takes
    1 in 100459
    1 in 1,0004,603
    1 in 10,00046,050
    44 proofs catch a batch that is 10% fake, 99 times in 100, however large.
    If answers are sealed before an unpredictable pick, and each proof is sound.
  6. Build a mathematical proof

    These GPU packages sit on the proof computer’s accelerator baseboard. Its host CPUs are on a separate motherboard. The proof computer works out mathematical evidence that links the selected question and recorded answer to the approved model. This extra calculation produces a proof that another computer can check. The verifier does not have to trust the operator’s account of what its servers did.

    GPU tray reference

    The eight GPU packages sit on a separate accelerator baseboard. Host CPUs and memory are in another tray. Compare NVIDIA’s GPU tray diagram and its separate CPU motherboard.

    Covers and GPU cooling hardware are hidden for this cutaway. This is an illustrative DGX-style layout, not the exact Azure or Verda host.

    More

    The proof computer proves the specified integer-model calculation. This is extra work, separate from serving the answer. Proof generation cost depends on the model, statement and proof system.

    Our zero-knowledge proof of a 7B model took on an 8-core cloud CPU.

  7. Check the proof on the verifier’s computer

    The proof travels over the network from the operator’s proof computer to the checker inside the verifier’s cage. The checker compares it with the saved question, answer and model fingerprint. If the check passes, that supports the claim that these values fit the approved calculation. It does not show that the answer is factually correct, or where the original work happened.

    More

    For each selected answer, the proof binds the recorded input, output and approved model fingerprint. A valid computation proof establishes this mathematical relation under the proof system’s assumptions; it does not establish that the answer is true, useful or safe.

  8. Check how far away fresh work could happen

    The timer in the checker rack would send the AI servers a challenge they cannot predict and time their reply. The checker would then verify the new calculation tied to that reply. The ring shows the distance limit that follows from the timing. These checks together could help detect work sent too far from the declared site.

    More

    One server would check proofs and act as the location landmark from a trusted position. It would send an unpredictable work challenge, time the reply committing to its result, then check the matching work evidence afterward. Timing would use a dedicated fast path so proof checking does not delay the measurement. A signed reply alone places the key holder; fresh work tied to the reply is needed to bound where computation happened. Light covers per millisecond of round trip, so a deadline allows at most . Computation and network delays enlarge that bound. The combined deployment has not been measured on the planned cluster: these are sizing numbers.

  9. Estimate the capacity left for other work

    The camera moves back to the operator’s racks and the verifier’s cage. The checker would compare the declared computing capacity with the work its checks support. Subtracting that work would give an upper limit on the capacity left for other jobs, such as training another model. Hidden or unlisted GPUs would make the limit invalid.

    More
    Account for the capacity
    Work target 90Capacity 100
    InferenceFiller (proposed)Remaining

    Illustrative units in one time window. Filler is proposed; the remaining bound depends on a complete inventory and checked work.

    Useful inference would count toward a work target below the capacity ceiling. When demand falls, fresh verifiable filler could supply the shortfall, including when inference is idle. That filler path is proposed, not implemented in this demo. Keeping a GPU busy is not enough: credited work must be fresh, not counted twice, and consume the resource being bounded. Hardware overclocking can raise the ceiling; it does not itself establish more credited work. The bound still needs a complete GPU list, no outsourcing, recorder coverage and compatible units in the same pool and time window. It bounds other uses of the chips; inference itself can still contribute to capability development. Publishing to outside witnesses is built but not tested yet.

What they don’t prove
  • That the GPU list is complete. The rental record is trusted.
  • That the model is safe, or what it was trained on.
  • That the proven integer version of the model answers like the released model. It matched 90.8% of next tokens on 17 test sequences (working paper, 7 Oct); other prompts may differ.
  • Anything about traffic that goes around the recorder.
  • Answers that weren't picked are covered only statistically, and today the proofs are being re-checked after a verifier fix.
  • Which GPU did the work. The timing checker's position would be trusted; the combined deployment has not been measured on the planned cluster.
  • Compute outside the declared cluster. The bound holds only if its premises hold.
  • That the parties are independent. In this demo Lucid would run the cluster, recorder, combined checker and timing server, and log witnesses. Combining roles does not add an independent party.

Every limit, with its conditions

Ask a question. Open its Passport.

See what was checked for each reply, and what remains unverified.

Explore the Passport this design would provide. Preview — not live yet.

Lucid

SmolLM2-135M Design preview Checking availability Checking
You

Recorded question: What is the capital of France?

Lucid

The capital of France is Paris.

Recorded 11 Oct 2026

Checking availability.

Not private: the chat server reads your question and the answer and sends them to the selected backend. Evidence downloads expire after an hour, and only request hashes and times are kept for the rate limit. Do not enter personal or sensitive information.

Recorded sample: nothing you type is sent. Replaying it needs JavaScript; the exchange and its Passport are shown instead.

No live answers yet.

Open the Passport below to see the proposed checks.

or watch the scripted walkthrough

Short paper

Checking what an AI datacenter computed, with proofs instead of trusted hardware

Don't trust, prove. Backed by math. The design, its threat model, what has been measured and what breaks it.