EVE AI Core
The Infrastructure of No.
Every governed decision emits an ECDSA P-384-signed, hash-chained, replayable record bound to the policy version in force. Below is a real sample — download it and verify the signature offline yourself.
What you see above is the certificate — reproduced byte-for-byte as it is published for download. It is a real, production-signed governed agent action: external.web_search, proposed by a research agent under schema eve.agent.action.v1. It records the action and the agent that proposed it, the disposition (EXECUTED) and the approval tier it ran under, the charter-compliance result with any violated principles, a trust score, an arguments hash, a content hash plus prior-record hash for the audit chain, and an ECDSA P-384 signature. It contains no customer data and no secrets, which is precisely why it can be published. It is signed with the live platform key, whose public half is published at /.well-known/eve-pubkey.
Because the displayed bytes are the downloaded bytes, verifying what you see is verifying what you get. The agent-governance path is shown here because it needs no customer context; when EVE evaluates a customer’s own policy, the decision record is signed by the same key under the eve.decision.cert.v8 schema. See EVE Proof for the production evidence format.
Schema & canonicalization registry. EVE signs more than one kind of artifact, and the canonical form follows the artifact rather than the other way round, so more than one is in use. Each row names the schema, the exact canonical form that is hashed, and the digest that results. The reference implementation for every row is the offline verifier published beside the sample at /assets/verify/ — read it rather than trusting this table.
| Artifact | Schema | Canonicalization |
|---|---|---|
| Agent action certificate — the sample on this page | eve.agent.action.v1 |
json.dumps(payload, sort_keys=True, separators=(",", ":")), UTF-8, then SHA-256 |
| Governed decision certificate (CoreGuard) | eve.decision.cert.v8 |
SHA-256(b"eve.decision.cert.v8\n" || JCS(body)) — RFC 8785 JCS applies to body first; the domain tag is prepended before hashing |
| CoreGuard audit record | audit_schema field |
json.dumps(payload, sort_keys=True), UTF-8, then SHA-256; rebuilds from the signed_fields manifest when one is present |
{
"payload_schema": "eve.agent.action.v1",
"note": "Real, production-signed agent Decision Certificate (schema eve.agent.action.v1), signed with the live ECDSA P-384 (AWS KMS) key. No customer data or secrets. Independently verifiable OFFLINE against the published public key at /.well-known/eve-pubkey (bundled here as sample-pubkey.json / sample-eve-pubkey.pub). Run: python verify_eve_decision.py sample-decision.json --pubkey sample-eve-pubkey.pub",
"certificates": [
{
"schema": "eve.agent.action.v1",
"certificate_id": "agentcert_ad44f44768134a07",
"proposal_id": "",
"action_id": "external.web_search",
"action_type": "external.web_search",
"agent": "research_agent",
"org_id": "demo",
"disposition": "EXECUTED",
"tier": "auto_execute_with_log",
"approval_mode": "AUTO_EXECUTE",
"charter_compliant": true,
"violated_principles": [],
"trust_score": 0.62,
"args_hash": "sha256-0494de4b458cc3b36c5a5bc6efadc6ba18a7ac3c9e541fcb46fbc8e21ad23494",
"reasoning": "Tier 2 \u2014 auto-executed under governance",
"timestamp": "2026-08-15T00:51:33.059249Z",
"prev_hash": "sha256-0000000000000000000000000000000000000000000000000000000000000000",
"content_hash": "sha256-3a0bb830c13b77866e5038887c201a9180ed08a3a220a2e362b7fff1473d355f",
"signature": "kms-ecdsa-p384-3066023100aff231b8756edc45e6f96858273c3f5e991802963cdd4b15837a55eb8ac0c7e8e4d96c8d914b811b293694d6d60bfb0d023100a1b93fdde1c4e130409c21ae09d69875eb875fedd1d7e2494e9e8d39dcabca31febdb76c441dc09bbc996003065dcc46",
"algorithm": "ECDSA-P384-SHA384-KMS",
"kid": "kms-ecdsa-p384:bt9gBUWssQJuLOHi",
"key_fingerprint": "sha256:6edf600545acb1026e2ce1e209e0819431ebeb64ecde119756ada4fb1daa4eb9",
"verification_key_url": "/.well-known/eve-pubkey"
}
],
"verification": {
"algorithm": "ECDSA-P384-SHA384-KMS",
"public_key_id": "kms-ecdsa-p384:bt9gBUWssQJuLOHi",
"public_key_fingerprint": "sha256:6edf600545acb1026e2ce1e209e0819431ebeb64ecde119756ada4fb1daa4eb9",
"public_key_file": "sample-pubkey.json"
}
}
kms-ecdsa-p384:bt9gBUWssQJuLOHi · SHA-256 fingerprint sha256:6edf600545acb1026e2ce1e209e0819431ebeb64ecde119756ada4fb1daa4eb9
Remove the six envelope fields — content_hash, signature, algorithm, kid, key_fingerprint, verification_key_url — then re-serialize what remains as JSON with sorted keys, UTF-8, and no insignificant whitespace.
SHA-256 the canonical bytes, prefix the result with sha256-, and confirm it equals the certificate’s content_hash.
Verify the ECDSA P-384 signature — over the content_hash string, not the payload — against the public key published at /.well-known/eve-pubkey.
A minimal Python check — the same two steps the published offline verifier performs, and what the live verifier at /verify does for production certificates:
import json, hashlib
from cryptography.hazmat.primitives.serialization import load_pem_public_key
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes
doc = json.load(open("sample-decision.json"))
cert = doc["certificates"][0]
# The six envelope fields are added after the payload is hashed, so they are
# excluded before canonicalizing.
envelope = ("content_hash", "signature", "algorithm", "kid",
"key_fingerprint", "verification_key_url")
payload = {k: v for k, v in cert.items() if k not in envelope}
canonical = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()
digest = "sha256-" + hashlib.sha256(canonical).hexdigest()
assert cert["content_hash"] == digest # step 1: the hash binds the payload
# Step 2: the signature covers the hash STRING, not the payload bytes.
der = bytes.fromhex(cert["signature"].split("p384-", 1)[1])
pub = load_pem_public_key(open("sample-eve-pubkey.pub", "rb").read())
assert isinstance(pub.curve, ec.SECP384R1) # refuse anything but P-384
pub.verify(der, digest.encode("utf-8"), ec.ECDSA(hashes.SHA384())) # raises if invalid
print("hash OK, signature OK:", cert["action_id"], cert["disposition"])Both files sit beside the sample: sample-decision.json and sample-eve-pubkey.pub. For any production certificate, fetch the key from /.well-known/eve-pubkey instead.
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.
eve-coreguard SDK performs it offline, and the live verifier at /verify checks production certificates with no login.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 (standard $37,500).
Related: EVE Proof · Live verifier · For model risk · For compliance.