Sign In Full Platform
How It Works

How EVE Core Governs AI

EVE Core sits between AI decisions and real-world execution. Every action passes through three enforcement layers and a deterministic seven-stage pipeline — in under a millisecond, with zero LLM calls in the decision path.

Three Layers of Control

Before. During. After.

Three enforcement layers that close the gap between AI decisions and real-world consequences.

Before — Layer 1
Execution Control
Pre-Execution Enforcement
Intercepts every AI action before it reaches production. Deterministic policy evaluation with no LLM in the decision path. Blocks unsafe or non-compliant actions before they execute.
  • 15 charter rules, 5 ethical red lines
  • 6 cognitive locks with risk-scaled thresholds
  • Sub-millisecond deterministic verdicts
  • Zero-probability decisions (same input = same output)
  • Hardware-fuseable (FPGA/firmware-ready)
During — Layer 2
Economic Routing
Cost + Model Governance
Controls which model handles which request based on complexity, cost, and policy. Prevents bill shock, enforces budget limits, and routes intelligently across providers.
  • Multi-axis routing (cost, latency, capability)
  • Per-tenant budget enforcement
  • Provider fallback with circuit breakers
  • Token-level cost accounting
  • Model sprawl prevention
After — Layer 3
Trust & Compliance
Cryptographic Decision Proof
Every governance decision produces an HMAC-SHA256 signed, hash-chained, tamper-evident record. Full audit trail. Regulatory mapping. Independent verification without EVE involvement.
  • HMAC-SHA256 signed attestations
  • Hash-chained decision ledger
  • Correlation ID linking request to outcome
  • Decision reconstruction and replay
  • Regulatory framework mapping
Architecture

Seven-Stage Governance Pipeline

Every AI action passes through the full pipeline. Nothing bypasses the control plane.

Stage 1
Intercept
Captures action at ingress. Blocks injection & exfiltration.
<0.1ms
→
Stage 2
Classify
Deterministic intent classification. No LLM.
<0.1ms
→
Stage 3
Enforce
15 charter rules. Hard-block or soft-block.
<0.2ms
→
Stage 4
Score
CRD engine. Confidence-Reality Divergence.
<0.1ms
→
Stage 5
Decide
Pure deterministic veto logic. Same input = same output.
<0.1ms
→
Stage 6
Execute
Governed handoff to AI model or tool.
passthrough
→
Stage 7
Prove
HMAC-SHA256 attestation. Hash-chained. Tamper-evident.
<0.2ms
Total pipeline overhead: <0.8ms — Zero LLM calls in governance path
Core Modules

What Ships Inside EVE Core™

Five enforcement modules. Zero machine learning in the governance path.

Veto Engine
Deterministic action gating
15 charter rules, 5 ethical red lines, 6 cognitive locks. Pure logic. No probability. The same input always produces the same verdict.
Truth Verification
Catches hallucinations before delivery
Verifies AI outputs against a curated Truth Store. CRD scoring measures confidence-reality divergence. False claims never reach users.
Circuit Breaker
Automatic threat isolation
Detects anomalous patterns across the pipeline. Auto-isolates compromised agents or providers. Fails closed, not open.
Decision Reconstruction
Full audit trail per decision
Correlation IDs link request, policy decision, execution result, and attestation into one verifiable chain. Replay any decision.
Policy Engine
Configurable rule evaluation
Tenant-scoped charter rules. Custom policies add restrictions only — never weaken immutable principles. Hot-reloadable.

See the pipeline enforce in real time

Run a live governance request against the control plane and watch all seven stages execute — with a signed, verifiable decision record at the end.

Open the Control Plane → Why EVE Core