AI Decision Evidence

Replay-verifiable
decisions

Signature verification proves a record was not altered. Replay verification proves something stronger: that the recorded verdict is exactly what the engine would decide again. Feed the certificate's deterministic inputs back into the same policy version, and the same verdict and reason code reproduce — every time.

Two Properties

Signature vs. replay

They answer different questions an examiner asks. EVE Proof gives you both.

QuestionAnswered byHow
"Was this record altered?"Signature verificationEd25519 over the canonical payload — any change breaks it.
"Is this the verdict the engine would give?"Replay verificationRe-evaluate the inputs against the same policy version; the verdict reproduces.
"Did the inputs match the record?"Digest checkThe retained inputs hash to the certificate's request_digest.
Worked Example

Replay in three checks

replay — Pythonsame inputs → same verdict
import hashlib, json, requests

# 1. the inputs you retained hash to the digest in the certificate
canon = json.dumps(saved_inputs, sort_keys=True, separators=(",", ":")).encode()
assert "sha256:" + hashlib.sha256(canon).hexdigest() == cert["request_digest"]

# 2. re-evaluate under the SAME policy version
r = requests.post("https://eveaicore.com/v1/decisions/evaluate",
                  headers={"Authorization": "Bearer eve_…"},
                  json={**saved_inputs, "policy_set": cert["policy_set"]}).json()

# 3. the verdict reproduces, deterministically
assert r["decision"]["status"] == cert["decision"]
print("✓ same inputs, same policy → same verdict")
Why It Matters

Determinism is the precondition for accountability

A probabilistic guardrail returns a likelihood that drifts between runs and model updates — it cannot be reproduced for an examiner. Deterministic governance can. Because the policy is decoupled from the model and versioned independently, the verdict in the certificate is not a snapshot of a moment; it is a function you can re-evaluate.

This is what lets a model-risk team confirm what a control did, when, and under which policy version — without relying on the first line's attestations. Read the governance argument on EVE Governance.

Keep Reading

Related

See a real certificate verify

Verify a live decision certificate in your browser — then hand the evidence to your own auditor and watch them verify it without us.

FAQ

Common questions

What is replay verification?
Re-running a certificate's deterministic inputs through the same policy version to confirm the engine returns the same verdict and reason code — proving the recorded outcome is reproducible, not just unaltered.
Do I need the raw inputs to replay?
Yes. The certificate binds the inputs by SHA-256 digest; to replay you supply the retained inputs (which must hash to that digest) and re-evaluate against the named policy version.
Is the verdict reproduced bit-for-bit?
The verdict and reason code reproduce deterministically every time. Volatile fields like timestamps differ, which is why the signature covers the recorded payload and replay covers the decision logic.
One Control-Plane Stack

Governance decides. Enforcement acts. Proof attests.

The EVE Control-Plane Stack

Explore the ecosystem