Skip to content

OpenVerification Proof-of-Control And OpenETR Analysis Note

This note reviews the Advanced AI Society's OpenVerification repository and the related Proof-of-Control standard in relation to OpenETR.

OpenVerification addresses a pressing problem in agentic systems: how an independent verifier can obtain evidence that an AI agent acted within defined controls, rather than relying on the agent or its operator to report that it did.

OpenETR addresses a different but adjacent problem: how consequential actions concerning a digest-identified Digital Artifact can be represented as end-verifiable evidence, and how defined rules derive consequential state from that evidence.

The approaches are strongly aligned, but they should not be collapsed into one model. Proof-of-Control is execution-centred. OpenETR is artifact-centred. Together, they can connect verifiable agent conduct to durable consequential state.

Status And Scope

Draft analysis note, reviewed 23 September 2026.

The repository named in the review request is primarily a use-case and calibration repository. The normative chapters, evidence schema, test vectors, reference implementation, mappings, and conformance material are maintained in the separate ov-poc-standard repository. Both were reviewed because the use-case repository cannot be assessed accurately without its normative context.

The materials are under active development. At the time of review:

  • the linked OpenVerification repository identified itself as Working Draft v0.1.4;
  • the standard repository identified its current material as v1.0 and open for public comment until 30 October 2026;
  • the tier chapter still contained substantial working-group questions; and
  • the repositories contained transitional version and release language.

This note therefore analyzes the architecture and current draft requirements. It does not treat every term, tier boundary, or conformance claim as settled.

Sources Reviewed

Executive Assessment

OpenVerification and OpenETR begin from the same architectural instinct:

A consequential claim should not be accepted merely because the application that made the claim says it is true.

Proof-of-Control applies that principle to an agent's execution. It seeks mechanism-generated evidence that actions were intercepted, evaluated against controls, bound to authority, and recorded at execution time. Its strongest tier requires the action to fail closed when the required evidence or control condition is absent.

OpenETR applies the principle to a digital thing and its lifecycle. It binds evidence to a Digital Artifact, links consequential actions into an Evidence Graph, and applies defined state transition rules to derive Consequential State.

The combined pattern is:

principal delegates bounded authority to an agent
  ->
Proof-of-Control mechanism evaluates and evidences the agent action
  ->
domain adapter determines whether the action is consequential for an artifact
  ->
OpenETR Evidence Event references the exact artifact and relevant PoC evidence
  ->
OpenETR rules derive consequential state
  ->
individual, community, institution, authority, contract, or law
determines recognition and real-world effect

The most important conclusion is that neither architecture subsumes the other. A Proof-of-Control record does not automatically establish a change in the state of a Digital Artifact. An OpenETR event does not by itself prove that an agent could not bypass the monitored execution path.

The OpenVerification Model

The Verifiability Gap

OpenVerification describes a gap between what increasingly autonomous agents can do and what an outsider can verify about whether they stayed within their controls. Application logs, operator reports, and agent explanations may all be useful, but they remain accounts produced inside the system being examined.

Proof-of-Control seeks evidence generated by the enforcing mechanism at an explicit action boundary. The draft requires evidence to be:

  • binary, so a claim can be evaluated against a defined threshold;
  • contemporaneous, so it is produced with execution rather than rebuilt later;
  • tamper-evident, so alteration, insertion, reordering, and some forms of equivocation can be detected; and
  • transparent, so residual trust assumptions are disclosed.

The standard also develops interoperability requirements for schemas, canonical serialization, algorithm identifiers, and positive and negative test vectors.

Six Evidence Domains

The draft organizes claims into six domains:

  1. provenance;
  2. privacy;
  3. portability;
  4. authorization;
  5. identity; and
  6. security.

These domains are not six OpenETR state dimensions. They are categories of claims about an agent system and its execution environment. A particular claim must identify the mechanism that evidences it and the residual parties, hardware, and mathematical assumptions that still have to be trusted.

Four Verifiability Tiers

The current draft uses four tiers:

Tier Current label Practical meaning
1 Assertion The operator states that a control held.
2 Attestation A named third party or auditor vouches for the claim.
3 Trust-minimized An outsider can verify the published evidence and tooling without operator credentials.
4 Self-enforcing Proof validity gates operation, so the in-scope action cannot proceed without the required evidence.

The proposed binary threshold for a Proof-of-Control claim lies between Tiers 2 and 3. The draft appropriately warns that cryptography alone does not determine the tier. A signed operator log can still require trust in the operator, while an openly monitored transparency mechanism may permit broader verification.

The tier chapter is candid about unresolved questions. It also states that the tier is only a coarse summary and cannot replace a claim-specific disclosure of residual trust.

The Action Interception Boundary

The most concrete contribution is the proposed Action Interception Gateway. For an in-scope action, the model seeks to:

  • route tool and effect invocations through a separate gateway;
  • capture evidence before, during, and after an action;
  • write the initial record before releasing the action;
  • bind the evaluated request to the request that is executed;
  • hold or constrain the credentials needed to cause the effect;
  • record policy, authority, agent, principal, target, and result data; and
  • fail closed when evidence cannot be generated at the claimed level.

This is a much stronger claim than signing an application log after the fact. It attempts to make evidence generation part of the execution path.

Verification Is Not Validation

The draft makes an important boundary explicit. Proof-of-Control can establish deterministic execution facts, such as which model and policy were used, which request was evaluated, which action was released, and whether it was within a defined authorization scope.

It does not establish that:

  • the model's output was correct, fair, or wise;
  • the selected controls were adequate;
  • the principal was legally entitled to grant the authority;
  • a downstream institution recognized the action; or
  • the external effect was valid or finally settled.

That distinction closely matches OpenETR's separation of verification from recognition and effect.

The OpenETR Model

OpenETR uses a small artifact-centred model:

  • A Digital Artifact is an identifiable digital thing bound to a digest.
  • An Evidence Graph is the end-verifiable evidence concerning consequential actions involving that artifact.
  • Consequential State is derived from that evidence according to defined state transition rules.
  • A Digital Original is the digital thing with independently verifiable consequences.
  • Recognition and effect remain outside the protocol and are determined by the relevant person, community, institution, authority, contract, or law.

OpenETR does not perform KYC, create legal identity, determine an agent's mandate, operate a universal policy engine, or guarantee that every relevant action passed through a particular application. Those functions belong to host systems, identity and authority services, domain rules, operational controls, and recognition regimes.

The Core Relationship

The two approaches focus on different questions.

Question OpenVerification Proof-of-Control OpenETR
Primary subject Agent execution and control adherence Digital Artifact and its Evidence Graph
Central question Did this agent action stay within the controls, and how can that be verified? What consequential state follows from valid artifact-specific evidence under defined rules?
Main boundary Tool or effect invocation Consequential action concerning an artifact
Main evidence Execution records, policy decisions, delegation, attestations, chain or Merkle commitments Anchor and later Evidence Events, prior-event links, signatures, linked evidence
Ordering Execution path and action sequence Artifact-specific evidence graph and state transitions
Completeness concern Could the agent act outside the interception path? Has the verifier retrieved the evidence needed to derive current state?
Enforcement Gateway, capability-bound dispatch, relying-party checks, fail-closed operation Host system and domain adapter enforce preconditions; protocol verifies published evidence
Result Verifiable claim about control adherence Reproducible consequential state concerning the artifact
External boundary Correctness and governance remain outside Recognition and effect remain outside

Their relationship can be stated plainly:

Proof-of-Control asks whether the agent acted within its controls.
OpenETR asks what consequence follows for the digital thing.

A Terminology Trap: Two Meanings Of Control

Both projects use the word control, but they use it differently.

In Proof-of-Control, control primarily means constraints governing an agent's execution: permissions, policies, interception, mediation, and evidence that the agent stayed within an authority envelope.

In OpenETR, control has historically referred to the controller and consequential transitions concerning a transferable or otherwise controllable record. The current OpenETR model is broader than transfer of control. It uses Evidence Events and Consequential State because issuance, revocation, attestation, discharge, and termination may be consequential without being a change of controller.

Integration material should therefore qualify the term:

  • execution controls for Proof-of-Control policies and enforcement;
  • controller state when an OpenETR domain models who controls a record;
  • consequential state for the broader OpenETR result; and
  • Proof-of-Control evidence for the evidence generated at the agent action boundary.

Without those qualifiers, a reader could incorrectly assume that PoC evidence proves control of the Digital Artifact, or that an OpenETR controller event proves the agent's complete execution path.

Where The Models Align

Applications Should Not Be Their Own Final Witness

Both projects reject the idea that a mutable database field or application log is sufficient for a consequential claim. Evidence should survive beyond the application's current presentation of events.

Evidence Should Be Bound To The Event It Describes

Proof-of-Control binds a policy decision to a canonical action snapshot and target resource. OpenETR binds an Evidence Event to a digest-identified artifact and relevant prior evidence. In an integration, both bindings are required.

Signatures Need More Than Syntax

A valid signature establishes integrity and attribution to a key. It does not establish that the signer was authorized, that the event was complete, that the policy was adequate, or that the action should be recognized. Both models benefit from making those dimensions visible instead of returning one undifferentiated trusted result.

Rules And Controls Must Be Versioned

PoC evidence identifies the policy bundle used to evaluate an action. OpenETR state derivation depends on an identified version of the domain transition rules. A combined record should preserve both. Otherwise, a later verifier cannot reproduce either decision.

Residual Trust Must Be Disclosed

Open verification is not trust elimination. A verifier may still depend on key custody, code measurements, hardware vendors, witnesses, relay retrieval, time sources, policy authors, identity issuers, and external evidence stores. The PoC trust-assumption disclosure is a useful pattern for OpenETR profiles.

Verification Does Not Create Effect

Both approaches can strengthen the evidence available to a decision-maker. Neither decides whether a legal, regulatory, contractual, institutional, or social consequence follows. That remains a recognition decision.

Where The Models Differ

Execution-Centred And Artifact-Centred Evidence

A PoC execution record is organized around an agent action and its path through an interception mechanism. An OpenETR Evidence Graph is organized around the Digital Artifact and the consequential actions concerning it.

One agent run may concern many artifacts. One artifact may accumulate evidence from many people, organizations, services, and agents over many years. The two graphs therefore have different roots, scopes, and retention requirements.

Adherence And Consequence

PoC can show that an action was permitted by policy and bound to the request that executed. It does not decide what state that action creates for a trade document, licence, certificate, warehouse receipt, or cultural artifact.

OpenETR can derive that state under a domain rule book. It does not establish that every tool call in the agent's preceding execution was mediated or that the agent had no bypass path.

Completeness

The PoC draft distinguishes after-the-fact verifiability from fail-closed coverage. At its Tier 3, evidence can be trustworthy without being complete. Tier 4 seeks to make absence meaningful within a defined execution boundary.

OpenETR has a related but different issue. A verifier can validate the events it has and still be missing a competing branch, revocation, or later event. Relay publication, redundancy, consistency checking, retrieval policy, and domain-specific finality all affect confidence in current state.

Neither project should claim universal completeness. Any completeness claim must name its boundary.

Enforcement

OpenETR defines end-verifiable evidence and state transition rules. It does not guarantee that a host application blocks an action before evidence is emitted. The host system remains responsible for enforcing domain preconditions and securing signing operations.

A PoC-style interception and capability mechanism could materially strengthen an OpenETR deployment by making publication of required evidence inseparable from a consequential system action. That would be an integration profile, not a new property automatically supplied by the base protocol.

How Proof-of-Control Evidence Fits Into An Evidence Graph

Proof-of-Control evidence should not automatically be treated as an OpenETR Evidence Event.

It may play three different roles:

  1. Evidence artifact. A PoC token or evidence bundle is itself a Digital Artifact with a digest and verification procedure.
  2. Linked supporting evidence. An OpenETR event may commit to or reference the PoC evidence that supports authority, policy evaluation, or execution.
  3. Evidence of a consequential action. Where the domain rules define the evidenced action as consequential, a domain adapter may emit an OpenETR Evidence Event that binds the action to the artifact and prior Evidence Graph state.

The domain adapter must make this classification. Routine agent telemetry should not flood the Evidence Graph, and a consequential action should not be reduced to an unlinked operational log.

Proposed Integration Pattern

1. Establish Principal And Delegation

The host system authenticates the person, organization, service, or community responsible for the action. It establishes a bounded delegation to the agent, including scope, audience, expiry, and any required human approval.

This is not performed by OpenETR. A Key-Based Identifier identifies signing material; it does not establish civil identity, organizational role, or legal authority.

2. Intercept The Proposed Action

The PoC mechanism receives the exact request before an effect occurs. It evaluates the request against the authority grant and policy bundle, records the decision, and binds any released capability to the canonical request.

3. Bind The Action To The Digital Artifact

For an OpenETR-relevant action, the evaluated snapshot should include at least:

  • Digital Artifact digest and digest algorithm;
  • proposed OpenETR action or domain action;
  • expected prior Evidence Graph event or graph head;
  • initiating principal and agent identifiers;
  • authorization or delegation reference;
  • policy bundle identifier and digest;
  • OpenETR domain profile and rule version;
  • target resource or relying system;
  • validity window, sequence, and replay protection; and
  • disclosure and evidence-retention references.

4. Execute Through A Bound Capability

The relying system or managed signer accepts only a capability bound to the approved artifact, action, prior state, and target. If the artifact or Evidence Graph head changes after approval, the capability must not authorize the stale action.

The PoC mechanism emits its execution evidence. Where the action is consequential, the domain adapter emits or permits the corresponding OpenETR Evidence Event. The event references the PoC evidence by digest or a privacy-preserving commitment rather than publishing a complete sensitive agent trace on a public relay.

6. Derive Consequential State

An OpenETR verifier validates the Evidence Graph records, applies the identified state transition rules, and reports the resulting Consequential State. It should report the PoC evidence and its verification status as a separate dimension.

7. Determine Recognition And Effect

The relevant person, community, institution, authority, contract, or law determines whether the artifact, evidence, and derived state are recognized and what real-world effect they should have.

A Combined Evidence Profile

A future integration profile could define a linked evidence statement such as:

artifact:
  digest: <algorithm-tagged artifact digest>

openetr_action:
  domain: <domain profile>
  action: <domain action>
  prior_event: <expected Evidence Graph event id>
  event_id: <resulting event id>
  ruleset: <identifier and digest>

execution_evidence:
  poc_profile: <profile and version>
  action_id: <PoC action id>
  agent: <agent identifier>
  principal: <principal identifier or protected reference>
  policy_bundle: <identifier and digest>
  canonical_snapshot: <digest>
  target_resource: <target>
  verdict: <allow, deny, or modify>
  evidence_root: <chain or Merkle commitment>
  tier_claim: <claim-specific tier>
  trust_disclosure: <reference>

This is illustrative, not a proposed wire-format change. The actual profile should reuse the PoC claim schema and OpenETR linked-evidence conventions rather than duplicate either one.

Tier Mapping To OpenETR

OpenETR should not claim a universal PoC tier. Tier placement is claim-specific and depends on the deployment, evidence mechanism, retrieval path, and residual trust assumptions.

OpenETR deployment characteristic Likely PoC interpretation
Application asserts current state without portable evidence Tier 1-like assertion
Operator signs its own event or state report Cryptographically protected, but potentially Tier 2 under the PoC trust model
Published events, rules, schemas, and verifier let outsiders reproduce a narrow claim May support a Tier 3 claim, subject to trust and completeness analysis
Publicly monitored roots or witnesses make equivocation detectable Strengthens a Tier 3 claim
Relying system refuses an in-scope effect unless valid action-bound evidence exists May support Tier 4 for that specific interaction
Base Nostr publication without a non-bypassable execution gate Does not establish Tier 4 by itself

This comparison is informative only. Formal tier claims belong to the OpenVerification conformance process, and the tier definitions remain under active development.

Security And Trust Considerations

Bypass And Coverage

A signed event proves that the key signed it. It does not prove that all relevant actions were routed through the signer or gateway. High-assurance profiles should test direct network paths, unmanaged credentials, alternate signers, and off-channel execution.

Equivocation And Competing Histories

A hash chain or signed graph detects modification relative to the history presented. It may not prevent a party from presenting different histories to different verifiers. Witnesses, independent relay observation, gossip, or externally anchored commitments can strengthen consistency evidence.

Time

An event's self-declared timestamp is not independently trusted time. Where ordering, expiry, or legal time is material, a profile should identify its time source and anchoring assumptions.

Identity And Authority

PoC and OpenETR both use cryptographic identifiers, but key possession is not the same as legal identity or authority. KYC, organizational accounts, delegation, role assignment, revocation, and recognition remain external responsibilities whose evidence may be linked.

Privacy And Graduated Disclosure

Agent traces may contain prompts, personal data, commercial secrets, credentials, policy details, or protected decision information. Publishing complete traces to open relays would often be inappropriate.

Integration should support graduated disclosure:

  • Check a claim or commitment without receiving the underlying material;
  • Present the evidence needed for a defined decision;
  • Share a broader evidence package under appropriate controls; and
  • Surrender a claim, capability, or control position where the domain requires relinquishment.

Public OpenETR events should normally carry digests, commitments, policy identifiers, and controlled references. Sensitive PoC evidence can remain in a protected store and be disclosed to authorized verifiers.

Canonicalization And Algorithm Agility

The PoC schema work is directly relevant to OpenETR. Cross-implementation verification requires exact canonical bytes, explicit algorithm identifiers, duplicate-key rejection, versioned profiles, and negative test vectors. A signature is interoperable only when independent implementations agree on what was signed.

Policy Adequacy

Perfect evidence of a poor policy is still evidence of a poor policy. A PoC Tier 4 action could be mechanically constrained by an inadequate policy. An OpenETR transition could be valid under a deficient domain rule. Governance, review, appeal, and substantive validation remain necessary.

Example: An Agent Transfers A Warehouse Receipt

Consider an agent asked to transfer a digital warehouse receipt after payment.

1. The receipt is a digest-identified Digital Artifact.
2. Its Evidence Graph identifies the current consequential state and controller.
3. The principal delegates a bounded transfer task to the agent.
4. The PoC gateway receives the exact proposed transfer.
5. It checks delegation, policy, counterparty, value, expiry, and current Evidence Graph head.
6. It emits the before record and releases an action-bound capability.
7. The managed signer signs only the approved OpenETR transfer event.
8. The event links the receipt, prior event, transferee, and PoC evidence commitment.
9. The PoC mechanism records execution and result evidence.
10. OpenETR rules derive the new consequential state.
11. The warehouse system, federation, counterparties, and applicable law
    determine recognition and real-world effect.

The PoC evidence strengthens confidence that the agent acted within the defined authority and that the executed request matched the evaluated request. The OpenETR Evidence Graph preserves the artifact-specific consequence. Neither one performs KYC, proves payment finality by itself, or determines legal effect.

Observations On The Current OpenVerification Repositories

Strong Features

The reviewed material has several unusually useful qualities:

  • it distinguishes evidence from operator assertion;
  • it treats residual trust as something to disclose rather than deny;
  • it separates deterministic execution facts from model correctness;
  • it recognizes that signatures and Merkle structures do not automatically create independent verification;
  • it addresses bypass, omission, equivocation, canonicalization, retention, and fail-closed behaviour;
  • it includes machine-readable schemas and negative test vectors; and
  • its use-case template explicitly requires residual trust and limitations.

Areas Still Maturing

The current materials should also be read as draft work:

  • the tier chapter contains unresolved definitions and review requirements;
  • the relationship between evidence and runtime enforcement is nuanced, while some summary language can appear categorical;
  • the evidence base for the tier taxonomy remains limited;
  • release and version language is transitional across repositories; and
  • the linked use-case repository's coverage report currently reports no mapped threats, while its credit-decisioning example predates or does not implement all current template metadata.

These observations do not undermine the architecture. They identify where an OpenETR integration should depend on explicit versioned requirements rather than broad labels.

Recommendations For OpenETR

  1. Adopt claim-specific trust disclosures. Extend verifier or domain profiles to state the parties, mechanisms, evidence stores, time sources, and retrieval assumptions on which a result depends.
  2. Define a PoC linked-evidence profile. Bind PoC action evidence to the artifact digest, proposed action, expected prior event, resulting event, and OpenETR ruleset.
  3. Keep PoC evidence distinct from Evidence Events. Let the domain adapter decide when execution evidence supports or constitutes a consequential action.
  4. Add completeness and equivocation outputs. Report whether the verifier checked only presented evidence, observed independent sources, or verified a witnessed or anchored history.
  5. Strengthen canonicalization tests. Add explicit algorithm tags, duplicate-key rejection, and cross-implementation negative vectors where OpenETR formats do not already cover them.
  6. Profile non-bypassable signing for high-risk actions. Test whether an agent can reach tools, credentials, or signers outside the approved path.
  7. Bind approval to the Evidence Graph head. A PoC capability must expire if the artifact or expected prior state changes before execution.
  8. Preserve privacy. Put commitments and controlled references on public relays, not complete agent traces or identity packages.
  9. Keep recognition explicit. Do not present a valid PoC record or valid OpenETR transition as automatic legal, contractual, or institutional effect.
  10. Run a combined pilot. A warehouse receipt or bill of lading transfer would test delegation, interception, managed signing, linked evidence, state derivation, disclosure, revocation, recovery, and recognition.

Policy And Standards Implications

The combined analysis suggests a useful standards principle:

Evidence that an agent stayed within its controls and evidence of what follows for a digital thing are complementary, but they are not the same claim.

Policy and procurement frameworks should ask separately:

  1. Who or what authorized the agent?
  2. Was the exact action evaluated and constrained at execution time?
  3. Can an outsider verify the resulting evidence?
  4. Which Digital Artifact did the action concern?
  5. What consequential state follows under which defined rules?
  6. Who recognizes that state, and what real-world effect does it have?

Keeping these questions separate prevents an execution assurance label from becoming an unsupported claim about legal effect, and prevents a valid digital record from becoming an unsupported claim about the completeness of an agent's execution history.

Bottom Line

OpenVerification Proof-of-Control and OpenETR address adjacent layers of a trustworthy digital process.

Proof-of-Control:
  Did the agent act within defined controls, and can an outsider verify it?

OpenETR:
  What consequence follows for this digital thing under defined rules?

Recognition:
  Should that consequence be accepted, and what real-world effect should it have?

The most promising integration is not a merger. It is a precise cryptographic binding between execution evidence and the artifact-specific event that changes consequential state.

Policy Brief