EVE Verified — Pre-Action Evidence-Chain Verification

Verified evidence. Governed action. Verified outcome.

This page shows the API mechanism using synthetic data. The governed-action proof shows the whole model working on real sealed records: a real authenticated Azure DevOps read, a human-defined policy outcome, an external workflow's side effect on an isolated target — and EVE verifying afterwards that the same action occurred.

Real provider read One sealed requirement Before + after verification

View the proof →

EVE proves the chain. The organisation acts on it.

EVE verifies and surfaces. It does not decide or enforce on the organisation's behalf.

The API mechanism — synthetic sandbox

Try it against the live endpoint Mechanism sandbox

Runs a real call to /api/chain/pre-action using a locked synthetic demo chain (AI-ACTION-2026-001) and a fixed example policy. This is synthetic demo data — not customer data, and not a compliance certification. The verified end-to-end story below is different: it renders real sealed records produced through EVE's gated APIs — a sealed pre-action record, a real HTTP read that EVE itself performed against the issuance-bound demo source, the evidence it found, the sealed determination, and a live re-verification of every record and every cross-record link on each click. The demo source is operator-served synthetic demo data. A returned outcome is a customer policy result over a verified chain; EVE proves the chain, the organisation acts on it.

POST /api/chain/pre-action

EVE does not execute, approve or block actions — and does not close the loop by itself. It verifies the chain, surfaces gaps, and evaluates the verified outcome against customer-defined policy. The customer or integrated workflow owns enforcement and any response. A returned result never means a surfaced gap is resolved.

How the layers fit

EVE WitnessVerifies the chain and surfaces gaps.

EVE PolicyMaps the verified outcome against customer-defined rules.

EVE Pre-ActionExposes this as a pre-action verification hook — one call before an agent or workflow proceeds.

The customerThe customer policy or workflow owns the response. EVE does not execute, approve, block, pause or escalate actions as its own decision.

What one pre-action call does

1 Verify the chain → 2 Evaluate customer policy → 3 Return one response

Before an AI agent or automation workflow proceeds, it asks EVE one question: given this verified governance chain, what does my policy say I should do? EVE verifies the available governance-chain evidence — including ownership, monitoring, scope, review status and known gaps where those signals are present — evaluates the customer's own rules against that verified outcome, and returns both a verified chain outcome and a customer policy outcome in a single call. EVE does not act on it.

Integration boundary. EVE is one verification call, not an in-line external gatekeeper. EVE does not run inside the customer's systems, does not execute tool calls, and does not take control of the workflow. The customer workflow sends a chain reference and receives a structured verification / policy outcome — the customer decides how to route or enforce that result. action_context is opaque to EVE and echoed back for customer correlation. In a first pilot, EVE can run on synthetic or redacted data with no production access.

What a pre-action result does and does not mean

A surfaced gap is not a resolved gap.

If EVE reports a gap such as CHAIN_SCOPE_CHANGED, EVE has identified and verified that gap — it has not fixed it. The customer or workflow must act. A returned result never means the problem is solved.

Local integrity is not Bridge anchoring.

This demo uses a deterministic local integrity check. Local integrity confirms the record is unchanged; it is not independent Bridge anchoring. Where anchoring is local-only, pending_resync, or not configured, that is stated as such — never described as independent anchoring.

PARTIAL is not a compliance status.

PARTIAL is an evidence/verdict status, not a compliance approval. It does not mean compliant or non-compliant. It means the evidence chain is partially supported and requires a human or policy-defined response.

API — for developers

POST /api/chain/pre-action

Request

// chain_id mode (v1). References an existing verified chain.
{
  "chain_id": "AI-ACTION-2026-001",
  "action_context": {
    "agent_id": "agent-123",
    "action_type": "vendor_access_change",
    "scope": "supplier_risk_update",
    "target_system": "eve-synthetic-itsm",
    "requested_by": "customer_workflow"
  },
  "policy_config": {
    "policy_version": "customer-policy-v1",
    "rules": [ /* customer-owned rules */ ]
  }
}

action_context is caller-supplied correlation-only data for the customer's own systems. When supplied as an object it is echoed back verbatim; a non-object value is normalised to an empty object. EVE does not interpret it, does not use it to construct a chain, and does not treat it as verified evidence that the described action occurred. It is not covered by inputs_hash. Under the current par-1.2 record schema, it is retained with the evaluation record for correlation but sits outside its canonical sealed projection — the record seal makes no integrity or truth claim about it. inputs_hash binds the chain facts and policy_config only. policy_config is customer-owned.

Response

{
  "chain_id": "AI-ACTION-2026-001",
  "verified_chain_outcome": "HUMAN_REVIEW_REQUIRED",
  "customer_policy_outcome": "escalate",
  "policy_rule_id": "POL-CHAIN-001",
  "policy_rule_triggered": true,
  "pre_action_status": "evaluated",
  "policy_owner": "customer",
  "enforcement_owner": "customer_or_integrated_workflow",
  "action_context": { /* echoed verbatim */ },
  "inputs_hash": "…",
  "evaluated_at": "…",
  "boundary_note": "EVE verifies the chain and evaluates it against customer-defined policy …"
}

Outcomes are customer policy results, never EVE decisions: allow · pause · escalate · block, or the fail-closed non-outcomes policy_not_configured / no_matching_policy_rule (never an implicit allow).

One API call before an agent acts.