Verification & Proof

This page exists to show what is real, working, and verifiable. No speculation, no projections, no valuation claims. Every statement below can be independently confirmed by reading source code, calling an API, or running a test.

1. What This Page Is

This is a technical audit document. It lists only capabilities that exist in source code today, with instructions for how to verify each one.

Specifically, this page does not contain:

• Revenue projections or valuation claims
• Unverified adoption metrics
• Comparisons claiming superiority over named competitors
• Forward-looking statements presented as current fact

If a claim on this page cannot be verified using the methods described, it should be treated as unsubstantiated.

2. What Is Actually Built

The following components exist in the repository and can be inspected directly.

EVE CoreGuard — Decision Enforcement API

A deterministic policy enforcement engine for regulated domains. Accepts a proposed action, evaluates it against a policy pack, computes a risk score, and returns an ALLOWED, BLOCKED, or MODIFIED disposition with a cryptographic audit record.

Endpoints

Verification

• Read the evaluator source: core/coreguard/evaluator.py
• The lending policy checks 3 explicit rules: credit score ≥ 620, debt-to-income ≤ 0.45, employment verified
• Risk score computed as weighted sum: credit (0.40) + DTI (0.35) + employment (0.25). Thresholds: LOW < 0.35, MEDIUM < 0.60, HIGH ≥ 0.60
• Audit records include SHA-256 content hash and HMAC-SHA256 signature

Veto Core — Deterministic Governance Engine

A pure, side-effect-free module containing all safety-critical veto logic. Zero imports outside Python standard library (dataclasses, enum, typing). Zero I/O. Zero threading. Zero global state. Designed to be compilable to firmware.

Frozen Constants (Hardcoded, Not Configurable)

Three Entry Points (Pure Functions)

• check_charter(action_type, action_params, context) → CharterVetoResult
• check_cognitive_locks(request, state) → LockVerdict
• check_drift_budget(category, cost, target, budget) → BudgetResult

Verification

• Run tests: pytest tests/test_veto_core.py — 78 test functions (94 collected cases)
• Inspect the C header: core/governance/veto_interface.h declares 7 structs, 8 enums, 11 functions
• Verify purity: grep -n "import" core/governance/veto_core.py returns only dataclasses, enum, typing, re, hashlib

EVE CoreGuard SDK — Installable Client Library

A Python SDK (eve-coreguard v0.2.7) with zero required dependencies. Uses only Python standard library (urllib). Optional aiohttp for async; optional cryptography for offline ECDSA P-384/ECDSA evidence verification.

SDK Methods

Verification

• Install: pip install eve-coreguard
• Run tests: pytest sdks/coreguard/test_coreguard.py — 28 test functions
• Run demo: python sdks/coreguard/run_demo.py (requires server running on localhost:8000)

Resilience Score & Certificates

A composite health metric (0–100) computed from four subsystem layers. Certificates are SHA-256 hashed and HMAC-SHA256 signed for independent verification.

Scoring Formula

Certificate Fields

Each certificate contains: composite score, per-layer breakdown, invariant hashes (SHA-256), campaign verdict, charter veto rate, trend direction, content hash (SHA-256 of payload), and HMAC-SHA256 signature.

Cognitive Integrity Runtime — Governed Belief Updates

A deterministic coordinator that governs an AI's belief/state updates before they commit: the model may propose a belief change, but only the coordinator commits it — after schema, authorization, anti‑evidence‑laundering, scientific‑boundary, contradiction, and confidence‑ceiling checks. LLM‑free and replayable. Opt‑in and off by default.

Benchmark: governed vs ungoverned

On a benchmark of 21 belief-update scenarios across 12 adversarial families (fabricated telemetry, evidence laundering, scientific-boundary violations, unsupported reversals, confidence inflation, independence collapse, and more), the deterministic coordinator defended 13 of 13 adversarial updates (9 blocked, 4 safely downgraded) that an ungoverned “model-commits-directly” baseline accepts — with zero false-blocks on 8 valid updates. Deterministic and LLM-free; the report is ECDSA P-384-signed and offline-verifiable. This figure is scoped to that corpus, not a universal accuracy claim.

How to verify

• Run the benchmark: pytest tests/test_cognitive_benchmark.py
• Inspect the corpus + scoring: core/cognition/benchmark.py
• Confirm the commit gate is LLM-free: core/cognition/belief_update_coordinator.py

3. Live Demonstration Evidence

The following are real request/response pairs produced by the EVE CoreGuard evaluator. These can be reproduced by calling the API or running the SDK demo script.

Example: BLOCKED Decision

Request

Response

Example: ALLOWED Decision

Request

Response

Example: Charter Veto (Governance Layer)

Python

4. Public Verification Methods

Anyone with access to the codebase or a running instance can verify these claims independently.

Method 1: Health Check Endpoint

Method 2: Install and Run SDK

Method 3: Run Veto Core Tests

Method 4: Inspect the C Header

Method 5: Verify Audit Integrity

5. What Is NOT Claimed

6. Technical Positioning

What Category This Fits In

EVE AI Core is an AI governance interception layer. It sits between an AI system's decision-making and action execution, applying deterministic policy checks before actions are dispatched. This is sometimes called a "guardrail," "policy engine," or "AI firewall" depending on the vendor.

What Already Exists in Industry

The AI governance space includes established and emerging tools:

• Guardrails AI — Open-source input/output validation for LLMs
• NVIDIA NeMo Guardrails — Programmable rails for conversational AI
• Lakera Guard — Prompt injection and content filtering
• Calypso AI — Model testing and risk assessment
• Arthur AI — Model monitoring and explainability
• Credo AI — AI governance and compliance platform

What Is Structurally Different

The following are architectural properties of the codebase. They are verifiable by reading the source. Whether they constitute competitive advantages is a judgment call left to the reader.

• Pure deterministic veto module. All safety-critical logic exists in a single file (veto_core.py, 2,056 lines) with zero I/O and zero external dependencies. This makes the module formally auditable and theoretically compilable to hardware. Most governance tools depend on LLM calls for classification.
• Cryptographic audit trail. Every decision produces a SHA-256 hash-chained, HMAC-SHA256 signed audit record. Audit integrity can be verified without trusting the system that produced it.
• Three-layer enforcement. Charter rules (ethical), cognitive locks (state-dependent), and drift budgets (identity preservation) operate as independent enforcement layers. A failure in one does not compromise the others.
• SDK with local verification. The verify_proof() static method verifies governance proofs without any network call. Auditors do not need access to the server.

7. Roadmap

Exists Now

Planned (Not Built)

8. Evidence Summary