Live · Evidence Verification for AI & Automated Systems

Verify before
systems act.

EVE verifies evidence against requirements fixed beforehand. Human-defined policy determines what happens next.

If required evidence cannot be verified, EVE refuses instead of guessing.

The customer workflow enforces the outcome. EVE does not execute the action.

See the governed-action proofSee the Azure-backed proof

A real action, blocked and then allowed by verified evidence — or a recorded Azure DevOps production verification — one sealed expectation, two fail-closed states, one authenticated read.

System wants to act→EVE verifies the evidence→Verified determination→Human-defined policy→Customer workflow acts
Explore
Verified demonstrations

What EVE actually did, and what was recorded.

These are demonstrations of what EVE actually did — with the evidence status stated for each one.

Production · Governed action · Before + after

Insufficient evidence blocked the action. Sufficient evidence allowed it.

One sealed requirement
A person changed the world between the runs
Verified again afterwards
Real provider readBlocked, then allowedReal side effectVerified after the fact

EVE read a real Azure DevOps work item, and the evidence was not sufficient — policy returned block and the external workflow did nothing. A person then moved the work item to Done. The same requirement, the same action, the same workflow: this time the evidence was sufficient, policy returned allow, the workflow acted, and EVE verified afterwards that it had.

See the block, the change, and the verified outcome

Recorded production runs against a real provider. The action changed state in an isolated demonstration target — no real vendor access was granted.

Production · Azure DevOps · Provider-backed

The expectation was sealed before the outcome existed.

One expectation
Two refusals
One verified outcome
SealedRefused twiceProvider-backed verification

EVE sealed what it required before the outcome existed. It refused when required access was unavailable — once for the source, once for the credential — then authenticated to Azure DevOps and verified the completed work item against the unchanged expectation.

See EVE refuse twice — then verify once

Recorded production verification, published as cryptographic commitments. Not a live check.

Scenario · Live-verified record

The approval still existed. The accountability chain did not.

An approval on file
Facts that changed
A question nobody could answer
ApprovedChangedAccountability gap surfaced

A risk decision was approved and remained on file. Months later the facts had moved and the chain behind the approval could no longer be reconstructed. EVE surfaced the gap rather than deciding what it meant.

Read the story

Anchored to a sealed record that is fetched and integrity-checked while you read.

Powered by the same verification engine

Verify before any system acts

The same verification engine across AI agents, governance workflows, software delivery and cryptographically verifiable evidence.

Pre-Action Verification API

AI Agent Pre-Action

Before an AI agent acts, verify the governance chain behind the action. One API call returns a verified chain outcome and a customer-policy outcome. Your workflow decides and enforces.

One API callVerified chain outcomeCustomer policy outcomeFail-closed by design
Learn more
Governance Chain Verification

EVE Verified GRC

Evidence-chain verification for governance workflows. Verify whether a chain was authorised, owned and monitored — for DORA, ISO 42001, TPRM and third-party risk. Surfaces gaps; humans decide.

EU AI ActDORA / ICT third-partyISO 42001TPRM / vendor access
Learn more
Developer Preview
Code-Change Verification

CodeGate

Before AI-generated code reaches the codebase, verify it in a sandbox and apply only on explicit human approval. Proposals go to a lab; nothing touches production without confirmation.

Sandbox validationHuman-approved applyAtomic writeFail-closed
Developer preview · internal
Cryptographic Seal Verification

Document Verify

Verify cryptographically sealed EVE documents. Confirm integrity and trace any document back to its original data source. Any modification produces a different hash.

SHA-256 sealSource traceabilityTamper detectionOffline-verifiable
Learn more

Supports governance requirements such as human oversight, record-keeping and traceability under the EU AI Act (Art. 12–14), DORA, ISO 42001 and TPRM. EVE provides verifiable evidence and surfaces gaps — it does not certify compliance, and the organisation acts on the result.

Built for two audiences

Choose your starting point

For developers

Build AI agents

Add one verification call before your agent acts. EVE returns a verified chain outcome and a customer-policy outcome; your workflow decides and enforces.

REST APILive democurl exampleFail-closed by design
Try Pre-Action API →
For enterprise

Govern critical workflows

Verify evidence chains, approvals and authority before critical decisions. EVE surfaces what the chain supports across the systems you already run.

DORAISO 42001TPRMAI governance
Explore Governance →
How EVE works

One verification chain. Every critical action.

EVE verifies each link in the chain behind an action and returns what the evidence supports. The system decides what happens next — EVE does not execute.

The chain
01
Identity
Who or what is requesting the action.
02
Authority
Whether it is authorised to act here.
03
Approval
Whether the required approval was given.
04
Policy
What the customer-defined rules say.
05
Evidence
Whether the chain is supported, partial or missing.
06
Decision
A verified chain outcome is returned.
▶
Execute
The customer workflow acts on the result. EVE does not execute.
The engine
Witness Mode
EVE observes and verifies. It does not act on the system’s behalf. Every verdict is a record, not an instruction.
Deterministic Core
Given the same inputs, approved premises and rule versions, the engine produces the same result — every time.
Evidence Chain
Each action is modelled as a chain of evidence: identity, authority, approval, scope and monitoring.
Cryptographic Sealing
Outcomes are hash-sealed and reproducible. Any change to the underlying evidence produces a different hash.
Fail-Closed
When a required source is unavailable or a required credential cannot be resolved, EVE refuses the verification path. In the provider-backed demonstration, no observation or determination was recorded and EVE did not downgrade to an unauthenticated read.
Witness
Mode
SHA-256
Sealing
Deterministic
Core
Append-only
Ledger
Why determinism

Principles

Formal Expansion
Fixed rules derive new conclusions as premises are approved. The core is stable. Knowledge expands only when new premises pass approval.
Witness, Never Decide
EVE observes, verifies and reports. It does not make autonomous decisions, classify incidents, assess materiality or determine compliance. Humans decide. EVE surfaces what the evidence, rules and signals support.
Deterministic Core
Same input, same approved premises and same rules produce the same output. No randomness in critical paths. No hidden decision-making. No unsupported conclusions.
Cryptographic Integrity
Every sealed output is verifiable. Every approved claim links to its source. Every record can be checked without trusting the system that produced it.
Governance Signals
Human approval is necessary, but not always sufficient. EVE surfaces authority, accountability and approval-scope gaps as deterministic governance signals. EVE does not decide what the signal means. A named human owner decides.
"
Like a formal system: the inference rules are fixed, and conclusions are derived from approved premises.
The core is stable — knowledge expands as new premises pass approval.
— The Determinism Manifesto

The Symbol

The e in EVE stands for Evidence & Verification Engine. It also references Euler’s number (e), reflecting the platform’s foundation in reproducible reasoning, formal systems and deterministic verification. The symbol represents a simple idea: critical decisions should be supported by verifiable evidence rather than assumptions.

The Engineering

EVE is built around deterministic verification. Given the same inputs, approved evidence, policy and rule versions, EVE produces the same verification outcome. If required evidence is missing, EVE returns NO_ANSWER. If authority, accountability or approval scope cannot be verified, EVE surfaces the governance signal rather than guessing. EVE verifies the chain. Organisations decide how to act.