New · synthetic dataMarine – Autonomous Operations. Replay autonomous missions on a chart and follow each recorded value back to its evidence.

Live · Evidence Verification for AI Agents & Autonomous Systems

Verifiable Autonomy.
Compliance by Design.

EVE is an evidence verification architecture for AI agents, autonomous systems and governed workflows. It is designed to verify the evidence behind authority, actions and outcomes — before, during and after execution.

One verification core. Multiple domains. Human accountability preserved.

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

Human-defined policy determines what happens next. The customer workflow enforces the outcome. EVE does not execute the action.

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
Verifiable autonomy

Autonomy needs evidence. Not just intelligence.

Autonomous systems can act, collaborate and adapt. But when something consequential happens, organisations need more than a system's account of its own behaviour.

EVE is designed to preserve verifiable evidence of what was authorised, what was observed, what was reviewed, and what remains uncertain. EVE verifies the evidence chain. The organisation retains responsibility for decisions and enforcement.

01

AI Agents & Autonomous Workflows

Governed delegation, bounded mandates, agent handoffs, review and correction loops, and traceable delivery evidence.

Demonstrated in bounded agent runs · producer-tested, not independently verified

02

Maritime & Autonomous Operations

Mission evidence, recorded observations, time and position provenance, offline operation, coverage gaps, and post-mission verification.

Demonstrated with synthetic maritime data only · no real sensor integration

For maritime teams →
03

Governance, Risk & Compliance

Evidence-linked controls, accountable approvals, policy scope, third-party risk and auditable gaps for governance processes.

Technical rule and control basis · rules not formally approved

One verification architecture with different domain integrations — not three separate verification engines.

Evidence, not certification

What “Compliance by Design” means here

Compliance by Design describes our engineering approach. EVE is designed to make evidence traceable, control results explicit, and human accountability auditable.

It does not certify compliance, establish the truth of sensor observations, or replace an organisation's legal and operational decisions. EVE is not certified against ISO 42001, and makes no claim of DORA compliance or of independent verification.

Design distinctions

Six distinctions we design and review against

They decide what a verification result may say — and what it must leave to the organisation.

  1. 01A signal is not automatically an incident.
  2. 02Verified evidence is not automatically compliance.
  3. 03Technical transport is not authorisation.
  4. 04A mandate for one action is not responsibility for the whole outcome.
  5. 05Local cryptographic integrity is not external historical anchoring.
  6. 06Producer review is not independent verification.

And one more for review itself: a reviewer saying ACCEPT is not proof that the review checks were performed.

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.

Production · Governed development · Published snapshot

See EVE govern the development of EVE itself.

Declared before it was written
Admitted through pre-action gates
Failed runs stay visible
Published as hash-verifiable snapshotsVerified in your browserNo access to the live store7/7 files byte-identical after hosting

EVE’s own development actions are declared, admitted through pre-action gates, measured, reviewed and only then eligible for promotion. Selected governed states are published as hash-verifiable snapshots that can be inspected without access to the underlying live store — and REFUSED, MISSING and UNRESOLVED states remain visible exactly as recorded.

Open the public governed-action demo

Published snapshots verified in the browser against their declared hashes. A snapshot shows what the owner chose to publish at a specific point in time; it does not assert that the complete underlying evidence set has been exposed or independently reviewed.

Recent engineering milestones

What we have shown — and how far it goes

Every item carries its label. A credible verification system has to report what is not established as clearly as what is.

REACHED · 8 November 2026

EVA Milestone A — accepted delivery after correction

Agent A built a component, agent B requested a correction, agent A corrected it, and agent B accepted. The handoff chain was verified by our own chain verifier.

Producer-verified. Not independently (E-3) verified: both agents ran on the same provider in separate contexts.

DEMONSTRATED · synthetic data

Voyage Evidence — maritime evidence chain

A cryptographically verifiable evidence chain from recorded observations to a post-mission report. Synthetic source data processed through the real EVE Voyage Evidence pipeline.

No real sensor integration has been demonstrated. EVE never states that a time, position or detection was correct.

Open the synthetic demonstration →
IN DEVELOPMENT · rules pending

DORA / GRC — evidence rules for ICT third-party risk

A technical rule and control basis exists: ten source-mapped draft evidence rules, and a demonstration module for sample assessments and workpaper exports.

None of the ten rules is formally approved, and no subject-matter-expert validation has been performed. The demonstration module has not been re-run since June 2026. Evidence coverage only — not DORA compliance.

For teams building autonomous maritime systems

An evidence layer for autonomous missions

Autonomous vessels and their operators increasingly have to document what a mission did — in a form that someone else can assess afterwards. EVE is designed as a vendor-independent evidence layer that sits beside the vehicle's own autonomy, sensors and control.

Online demonstration · synthetic data

Marine – Autonomous Operations

The main demonstration: autonomous missions during operation.

  • Vessels, missions and an operations overview on a chart
  • Replay of recorded positions and events, step by step
  • Device-signed checkpoints protect the recorded chains; every other value is marked as bound by a file hash or as derived by the verifier
  • A mission report that states per condition SUPPORTED, PARTIAL or NOT_EVALUATED, with downloadable files and their SHA-256 values
Open Marine – Autonomous Operations
Online demonstration · synthetic data

EVE Voyage Evidence

The complementary demonstration: one claim reviewed after the fact.

  • A claim about anchoring in a protected area, checked against a sealed evidence package
  • Chart, replay of the recorded track, trust panel and evidence chain
  • Technical and legal review packages as exports
Open EVE Voyage Evidence

Both demonstrations use synthetic data only: no real vessel, sensor or fleet connection. The chart is context, not evidence, and not for navigation. No external time anchor is demonstrated.

Timestamped, georeferenced mission records — sealed, with the source and clock behind each observation

Demonstrated · synthetic data

Post-mission report that states, per condition, what the records support, partly support, contradict or did not evaluate

Demonstrated · synthetic data

Link outages and resynchronisation recorded as gaps — "we found nothing" never becomes "it did not happen"

Tested locally

An exported package that a third party can re-verify without access to EVE

Implemented · producer-reproduced; no external re-verification yet

Records of autonomous decisions and operator actions, where the platform exposes them

Exists for software actions · not yet applied to vehicle autonomy

One evidence contract across platforms — not tied to a vehicle maker or sensor vendor

By design

What EVE does not do

Those belong to the vehicle and its operator. EVE never states that a time, a position or a detection was correct — it shows what was recorded and what a report rests on.

  • navigation or collision avoidance
  • sensor fusion
  • threat, vessel or object detection
  • attribution of an observed activity
  • alarms, kill switch or vessel control
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
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
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

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.

Three starting points

Choose your starting point

Prefer to talk first? Discuss a pilot or contact us.

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 →
For teams building agents or autonomous systems

Start a bounded engagement

A version-bound technical review, a scoped pilot partnership, or agent workflows developed and qualified with your team. Fixed scope, documented findings, stated limits.

Agent Verification ReviewPilot PartnershipsEVA Business Workflows
See the services →
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.