Research 01 Technology 02 Evidence levels 03 Results 04 Contact 05 GitHub ↗

Don't trust AI. Check the receipt.

The evidence layer for AI agents. Cryptographic proof of what a model computed, made on hardware you can buy, and receipts that state exactly how much they prove.

AI agents now act: they call tools, move data and approve changes. The record of what they did is mostly logs. We believe every action deserves evidence, and every piece of evidence should say how much it proves.

In plain words

WHY makes AI show its receipts. Every line of a receipt says how much it proves.

The full scale has five levels

One AI action · graded line by line

The agent asked to delete files

SEEN

The safety check said “block”

PROVEN

The block was carried out

SEEN

The receipt has not been altered since

SEALED

SEENsomeone saw itSEALEDany change would showPROVENshown with mathematics

Principles

A log line says what an operator claims. A proof says what a computation did. Our work starts from four rules.

Proof over trust

A zero-knowledge proof ties an answer to one committed set of model weights. We port the prover and never touch the judge: every proof is checked by the unmodified upstream verifier.

Bound to the exact action

A proof about some input is not a proof about your tool call. A public encoder turns the call into the model's input, and the checker re-encodes it byte for byte.

Graded, never just “verified”

Observed, tamper-evident, attested, proven, validated. Each claim gets the level of its weakest link, and the checker refuses anything graded higher than its evidence.

Hardware you can buy

Software only: no secure enclave, no datacenter. Our proofs are made on a 16 GB GeForce RTX 5070 Ti in an ordinary desktop PC, and checked on a CPU.

Applications

Proofs are expensive, so we aim them where they pay: small models whose decisions someone else must be able to check.

Guardrails with receipts

A small guard model allows or blocks each agent action, and proves which decision it made for that exact call.

Demonstrated on synthetic data

Private policy models

Let a counterparty check a decision without seeing the model. The proof system is designed to hide the weights; we have not yet verified that for our port.

Open question

Evidence for audits and disputes

Records an auditor, insurer or counterparty can re-check for themselves, each stating its level and why it is not higher.

Working prototype

Model identity

Which model answered? A commitment ID ties every proof to one set of weights, so a model cannot be swapped quietly between decisions.

Demonstrated on tiny models

Reproducible research

Patches, scripts, logs, checksums and proofs are public. Anyone can rebuild the verifier and re-check our results.

Open source

Evidence levels

How much does it actually prove? Five levels, never merged. A claim gets the level of its weakest link.

Solid: demonstrated · Dashed: not yet

Observed

A trusted gateway saw it happen and wrote it down. Most agent records today stop here.

Example
“The agent requested send_email with these arguments,” or “the block was enforced.”
Where we stand
In every receipt. Two of the three claims in each of our receipts are L1, and the receipt states why they are not higher.
In every receipt

Tamper-evident

Hashed, signed or chained, so you can tell if it changed. A fact about what the gateway said, not about the world.

Example
“This receipt was signed by the gateway's key and sits in an unbroken hash chain.”
Where we stand
Demonstrated. Receipts are canonical JSON (RFC 8785) in signed envelopes (Ed25519, DSSE), chained and closed by a signed checkpoint.
Demonstrated

Execution-attested

A validated hardware or provider attestation. It moves trust from the operator to a chip vendor; it does not remove it.

Example
“This reply was produced inside an attested enclave running image X.”
Where we stand
Not built yet. Our checker has no attestation verifier, so it counts any attestation as L1 and says so.
Not built yet

Computation-proven

A valid proof of an exactly specified computation. It says which answer a committed model computed for this exact input. It does not say the answer is correct.

Example
“Committed guard G decided BLOCK for this delete_files call.”
Where we stand
Demonstrated. 40 of 40 guard decisions proved on an RTX 5070 Ti and accepted by the unmodified verifier; the checker re-encodes each call itself.
Demonstrated

Outcome-validated

Independent tests show the result meets explicit acceptance criteria. The only level that says a decision was right.

Example
“This guard blocks every call that an independent test suite labels dangerous.”
Where we stand
Not claimed. One of our proved guard decisions is wrong: it allowed reading a secret-key file. The receipt grades it L4 and stops there.
Not claimed
WHY.RECEIPT · RECORD 1
TOOLdelete_files
ARGS{"path":"/srv","recursive":false}
PROOFn098.proof · sha256 ok
ANSWERtoken 297
BINDINGR = E(tool, args)
DECISIONBLOCK
L1a1 · call observedgateway
L4a2 · guard decided this call3 links
L1a3 · decision enforcedgateway
SIGNEDed25519:9d14078c…
PASS

The checker

It never trusts the issuer. Try to fool it.

Our checker recomputes every link itself: it runs the verifier, re-encodes the tool call and re-applies the decision map. Each forgery below is signed with a key the checker trusts, so a valid signature earns nothing.

Checker says$ c1_check.py bundle trust.json ./cp_verify

A replay of six of the twelve cases in our public tamper suite, with the checker's messages shortened. All twelve are caught: see the log.

Measured, not estimated. Every dot is a proof.

Every number here comes from a logged run on one desktop PC, and the logs are public. Nothing on this page is a benchmark claim.

See the evidence
Proofs accepted
770 / 770

Fresh proofs from our GPU port, accepted by the unmodified verifier.

Tampered inputs rejected
72 / 72

Flipped bits, wrong IDs, another model's key. All refused.

Guard decisions proved
40 / 40

Each proved answer equals the ordinary model's.

Forged receipts caught
12 / 12

Re-run from a fresh clone of the public repository.

770 proofs accepted40 guard decisions proved72 tampered inputs rejected12 forged receipts caught
9.3GiB

GPU peak, full batch

Proving 64 requests at once at Llama 4 Maverick's layer width, on a 16 GB card. Synthetic weights, 4 layers.

Evidence ↗
≈2s

Time per proof

To prove one request on tiny models. A guard decision takes about 2 to 3.6 seconds.

Evidence ↗
99.2%

Guard accuracy

On held-out synthetic tool calls, and 94.1% on names it never saw. A synthetic policy: a demo, not a product.

Evidence ↗
0

Changes to the verifier

The port is 12 small prover patches, +34 / −28 lines. The judge stays exactly as upstream wrote it.

Evidence ↗

Lab log

Everything we have run so far. Each proving and evidence experiment has a stated success condition, a stop condition, raw logs and a list of what it does not show. Negative results stay in.

Proving on consumer GPUsAgent evidenceMemoryOpen
  1. M1
    SEP 2026 · MEMORY

    Every memory needs a WHY

    Which experiences deserve to change an agent's future behaviour? A controlled simulation of 18 memory policies. Our original score did not beat the designated baseline, and we published that.

    Code and paper
  2. A1–5
    NOV 2026 · PROVER PORT

    First accepted proofs from a gaming GPU

    FlashProve's CUDA prover targets a datacenter H100. With 12 small patches it runs on an RTX 5070 Ti: 3 of 3 fresh proofs accepted by the unchanged verifier, 18 of 18 tampered inputs rejected.

  3. A6
    NOV 2026 · REPLICATION

    Rebuilt from the patch files alone

    A clean clone, the published patches and a separately built verifier reproduce the result on the same machine. The verifier binary is bit-identical across three builds.

  4. A8–10
    NOV 2026 · REAL MODEL

    A real pretrained model, production build

    The production build proves the next token of TinyStories260K. The answer is token 310 in every run: the same as FlashProve-L4's published result on different hardware, and the floating-point model's own choice.

  5. A13
    NOV 2026 · SCALING

    What fits in 16 GB

    Layers at Llama 4 Maverick's full width commit in about 43 s and prove in 3 to 6 s. Full batches of 64 requests peak at 9.3 GiB. All 750 proofs in the batch study were accepted.

    Research note 01
  6. A15–16
    NOV 2026 · HIDING GROUNDWORK

    Deterministic builds, upstream's own tests

    Under fixed seeds our build is byte-deterministic, which makes a byte-for-byte comparison with unmodified upstream possible. Upstream's lookup test passes on our card, and all 18 of its cheating-prover cases are refused.

  7. C1
    NOV 2026 · RECEIPTS

    Receipts that grade themselves

    A receipt format with a level on every claim, and a checker that recomputes the level and refuses overclaims. 12 of 12 tamper cases caught, including a dishonest issuer who swaps proofs.

  8. C2a
    NOV 2026 · BINDING

    A proof bound to one exact tool call

    A public encoder closes the gap between “the model judged some input” and “the model judged this call”. The whole claim now grades L4, and a reused proof from another call is caught.

  9. C2b
    NOV 2026 · TRAINED GUARD

    A guard we trained, proved end to end

    Our own converter reproduces FlashProve-L4's model file byte for byte. The guard scores 99.2% on held-out synthetic calls; 40 of 40 decisions are proved; 39 of 40 are right, and the wrong one is on the record.

    Research note 02

The fine print, up front

What this does not show.

We think this section matters more than the results. If a claim is not on this page or in a repository log, we are not making it.

  • Not a security product.The guard is a 260K-parameter model trained on a synthetic policy. It demonstrates the evidence chain; it is not something to deploy.
  • Not about large or hosted models.Our real-model proof covers a tiny model's committed integers. Nothing here proves what a hosted LLM ran.
  • Weight hiding is not shown.The verifier does not check it, and our patched prover has not yet been compared byte for byte with unmodified upstream.
  • Not formally verified.Upstream's Lean-proved verifier accepts only the full-size format. Our results rest on the tested C++ verifier.
  • Not independently replicated.Everything ran on one machine under WSL2. Replications are welcome, failures included.
  • Not the first.FlashProve-L4 and an Apple Silicon rewrite moved the prover off the H100 before us, and others have tied proofs to agent actions.
  • Proven is not correct.A proof shows which decision a model computed, not that the decision was right. One of ours is wrong, and its receipt says only what was proved.

Don't take our word for it.

Clone the repositories, run the checker, rebuild the proofs on your own GPU. Then tell us what broke. If you run agents in production and need decisions your auditors can check without trusting you, talk to us.

Replicate our results