What is in the examiner evidence pack?

A sample EVE decision certificate in the same shape EVE produces for every governed decision: the proposed action, the ALLOW/MODIFY/BLOCK verdict and reason code, the policy set and version in force, a risk score, a content hash and prior-record hash for the chain, and an Ed25519 signature. It is an illustrative sample signed with a published demo key so you can verify it offline yourself.

How do I verify a certificate offline?

Remove the signature block, canonicalize the remaining fields (sorted keys, UTF-8, no insignificant whitespace), and verify the Ed25519 signature against the public key. For this sample, the demo public key is on the page; for production certificates, the platform public key is published at /.well-known/eve-pubkey and any certificate can be checked at /verify. No EVE account is required.

Is the sample signed with the production key?

No. The sample is signed with a clearly-labeled demo key so it is safe to publish and independently verifiable. Production decision certificates are signed with the platform Ed25519 key whose public half is published at /.well-known/eve-pubkey.

Examiner Evidence Pack — Sample Signed Decision Certificate

What Is In The Pack

One decision, fully evidenced

The pack is a single decision certificate in the exact shape EVE produces for every governed decision: the proposed action, the ALLOW / MODIFY / BLOCK verdict and reason code, the policy set and version that governed it, a risk score, a content hash plus prior-record hash for the audit chain, and an Ed25519 signature. This sample is signed with a clearly-labeled demo key (published below) so it is safe to share and you can verify it yourself. Production certificates are signed with the platform key whose public half is published at /.well-known/eve-pubkey.

{
  "certificate_version": "eve.decision.v1",
  "request_id": "req-2026-07-14-000042",
  "tenant_id": "org_sample",
  "timestamp": "2026-07-14T15:04:05Z",
  "proposed_action": {
    "type": "loan_approval",
    "amount": 50000,
    "applicant_ref": "app_9f3c"
  },
  "model_output": {
    "decision": "approve",
    "confidence": 0.91
  },
  "decision": {
    "status": "MODIFIED",
    "reason_code": "lending.dti_over_threshold",
    "modification": "route_to_manual_review"
  },
  "policy": {
    "policy_set": "lending_v1",
    "policy_version": "2026.07.1"
  },
  "risk": {
    "level": "MEDIUM",
    "score": 0.42
  },
  "evidence": {
    "canonicalization": "sorted-keys JSON, UTF-8, no insignificant whitespace",
    "hash_alg": "sha256",
    "prev_record_hash": "sha256:9b1f...c204"
  },
  "signature": {
    "alg": "ed25519",
    "public_key_id": "demo-examiner-sample-2026",
    "content_hash": "sha256:72d4fcebb0777799e3cbcf453cadfaf052e943f4f76e7ed0505cd7d9938b5d49",
    "value": "ed25519:e78313dfbd4b6e702b6e7b52ea0b321d7da6ce2396182bc1458f76dcee159932ee44a354b5e2bd7edffd9ea470a8a8e8074b1fcb2f40301269180ba9616c1d0f"
  }
}

Download sample-decision-certificate.json Demo public key (hex): 77be917626243bd07e5d703372fea46d686c5e2ecb178c13e4bf809040b8639f

Verify It Offline

Three steps, no EVE account

01 Canonicalize

Remove the signature block and re-serialize the remaining fields with sorted keys, UTF-8, and no insignificant whitespace.

02 Check the hash

SHA-256 the canonical bytes and confirm it equals the certificate’s content_hash.

03 Verify the signature

Verify the Ed25519 signature over the canonical bytes against the demo public key (or the published platform key for production certs).

A minimal Python check — the same procedure the eve-coreguard SDK performs, and what the live verifier at /verify does for production certificates:

import json, base64, hashlib
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

cert = json.load(open("sample-decision-certificate.json"))
sig = cert.pop("signature")                       # remove signature block
canonical = json.dumps(cert, sort_keys=True, separators=(",", ":")).encode()
assert sig["content_hash"] == "sha256:" + hashlib.sha256(canonical).hexdigest()
pub = Ed25519PublicKey.from_public_bytes(bytes.fromhex(DEMO_PUBLIC_KEY_HEX))
pub.verify(bytes.fromhex(sig["value"].split(":", 1)[1]), canonical)   # raises if invalid
print("signature OK — verdict:", cert["decision"]["status"])

Set DEMO_PUBLIC_KEY_HEX to the hex value above. For production certificates, fetch the key from /.well-known/eve-pubkey instead.

Why It Holds Up

Reproducible by construction

Because the verdict is deterministic — the same normalized input under the same policy version yields the same result — the certificate is not just a log line. It can be re-derived and re-verified long after the decision was made, and it names the exact policy version that governed it. That is the difference between “we have logs” and “here is the decision, signed, and here is how to prove it.” See EVE Proof for the full evidence layer.

Common Questions

FAQ

No. It is signed with a clearly-labeled demo key so it is safe to publish and independently verifiable. Production decision certificates are signed with the platform Ed25519 key whose public half is published at /.well-known/eve-pubkey.
No. Verification uses only the certificate, the documented canonicalization procedure, and a public key. The published eve-coreguard SDK performs it offline, and the live verifier at /verify checks production certificates with no login.
Yes. Every verdict — ALLOW, MODIFY, and BLOCK — is bound to the policy version and emitted as a signed, hash-chained record. A block still produces the evidence that explains why.

For technical and audit buyers

Book an architecture review, or run a pilot

Walk your model-risk, security, or engineering team through where the gate sits, how the evidence is produced, and how offline verification works — then run one of your real decisions through it. Founding design-partner pilot from $27,500.

Book an Architecture Review Book a Pilot

Related: EVE Proof · Live verifier · For model risk · For compliance.

The evidence an examiner can actually inspect