# **Make the Machine Answerable: Decision Provenance, Evidence Integrity, Causal Reconstruction, and Accountability Infrastructure for Evulgare**

## **Executive Summary**

The proliferation of autonomous systems, ranging from human-supervised machine learning implementations to machine-sovereign infrastructures, fundamentally alters the landscape of technical accountability. Evulgare’s central proposition is straightforward yet paradigm-shifting: make the machine answerable. The architecture presented in this report establishes that a machine’s technical answerability is completely distinct from legal liability or moral fault. Evulgare does not determine who is legally liable, nor does it compute a universal blame score. Instead, it provides the deterministic, mathematically verifiable infrastructure necessary to preserve the institutional history of autonomous decisions1.  
When autonomous agents take consequential actions, standard operational logs fail to capture the governance-relevant record of how a decision was reached2. Standard event logs record that a state changed; decision provenance records why the state changed, what evidence supported the change, what authority permitted it, and what alternatives were rejected3. This reference architecture specifies the structural models, cryptographic ledgers, and causal reconstruction mechanisms required to prevent two persistent errors in systems engineering. First, it prevents the reduction of an entire technical history to the mere assertion that a human approved it. Second, it prevents the reverse error of automatically assigning human-like agency, moral fault, or legal culpability to a machine algorithm.  
Through the rigorous integration of W3C PROV-DM conceptual models2, RFC 6962 append-only cryptographic log schemas6, ISO/IEC 27037 digital evidence chain-of-custody standards9, and causal inference frameworks11, this report details a comprehensive accountability infrastructure. It delivers thirty named invariants, fifteen synthetic case studies, deterministic replay contracts, and comprehensive schemas for both human and machine review environments, ensuring that every algorithmic decision can be mathematically traced, causally reconstructed, and institutionally reviewed.

## **Mandatory Epistemological Distinctions**

To prevent the semantic collapse of technical architecture into legal philosophy, the Evulgare infrastructure enforces twenty-five mandatory epistemological distinctions. These distinctions form the boundaries of what the system can technically assert and must be embedded within the institutional governance model.

| Concept A | Concept B | Architectural Distinction |
| :---- | :---- | :---- |
| **Event Log** | **Decision Provenance** | An event log records discrete state transitions or network emissions, common in standard NIST SP 800-92 implementations13. Decision provenance exposes the complete decision pipeline: the chain of inputs, the applied logic, the authorization envelope, and flow-on effects1. |
| **Record Presence** | **Record Accuracy** | Cryptographic ledgers prove that a record is present and unmodified since ingestion7. They cannot definitively prove that the contents of the record accurately reflect the external physical world at the time of ingestion. |
| **Record Integrity** | **Factual Truth** | Integrity guarantees that a payload has not suffered unauthorized modification. Factual truth requires external corroboration and ontological alignment, which software infrastructure cannot inherently guarantee without physical-world anchoring15. |
| **Generated Rationale** | **Supporting Evidence** | A generated rationale is the narrative or structured output a model produces to explain its action. Supporting evidence consists of the verifiable, external data artifacts (such as retrieval-augmented generation inputs or sensor data) actually processed by the model16. |
| **Model Output** | **Institutional Decision** | A model output is a mathematical prediction or generation based on vector weights. An institutional decision occurs when that output is accepted, explicitly or implicitly, under the delegated authority of the deploying organization2. |
| **Human Acknowledgment** | **Procedural Confirmation** | Acknowledgment implies cognitive processing and comprehension of information. Procedural confirmation merely proves that a user interface event, such as clicking a button, occurred, which offers no guarantee of comprehension. |
| **Procedural Confirmation** | **Merits Review** | Procedural confirmation validates that a workflow step was executed. Merits review evaluates the substantive correctness, wisdom, and safety of the decision against institutional and legal standards. |
| **Merits Review** | **Independent Judgment** | Merits review checks an existing proposal for flaws. Independent judgment requires the reviewing entity, whether human or machine, to formulate its own hypothesis prior to comparing it against the primary agent's recommendation. |
| **Machine Report** | **Independent Machine Review** | A machine report is a self-diagnostic output. An independent machine review within the Eviulon context requires a physically and logically isolated intelligence, operating on different training lineages, to evaluate the primary actor2. |
| **Replayability** | **Correctness** | Deterministic replayability ensures a system yields the exact same outputs given the exact same historical inputs and seeds. It does not establish that the output was factually correct, lawful, or safe. |
| **Deterministic Output** | **Lawful or Wise Output** | A deterministic system is mathematically predictable and stable. A deterministic system can flawlessly and predictably execute a catastrophic, illegal, or unethical policy. |
| **Technical Causation** | **Legal Liability** | Technical causation identifies the computational conditions and data inputs that triggered an outcome11. Legal liability is a socially constructed determination of fault applied by human judicial systems. |
| **Technical Rollback** | **Completed-Harm Remedy** | Technical rollback reverts a database or system state to a prior snapshot. A completed-harm remedy addresses external, real-world damages (physical, financial, reputational) that cannot be undone by altering a data structure. |
| **Historical Authority** | **Current Authority** | Historical authority validates whether an agent had permission to act at the precise microsecond of execution. Current authority dictates who can review, alter, or act upon the system in the present moment. |
| **Missing Evidence** | **Evidence That Never Existed** | Missing evidence was successfully collected or generated but subsequently lost, dropped, or corrupted. Evidence that never existed points to a fundamental sensor, logging, or system design failure at the time of the event. |
| **Invalidated Evidence** | **Deleted Evidence** | Invalidated evidence remains in the append-only ledger but is marked by a superseding event as unreliable or false5. Deleted evidence is cryptographically shredded; Evulgare prohibits deletion in canonical chains. |
| **Superseded Policy** | **Historically Active Policy** | A superseded policy is one no longer in effect. A historically active policy is the exact rule set, verified by hash, that governed the machine at the precise moment the decision was authorized. |
| **Confidence** | **Truth** | Confidence is a probabilistic score assigned by a model to its own output. Truth is the factual accuracy of the output. High confidence regularly correlates with confabulation in generative models17. |
| **Connectivity** | **Trust** | Connectivity establishes that two nodes can exchange network packets. Trust requires cryptographic attestation of identity, software supply chain integrity (e.g., SLSA provenance), and policy alignment19. |
| **Technical Capability** | **Delegated Authority** | Technical capability defines what the system has the API access and processing power to do. Delegated authority is what the institutional principal has explicitly permitted the system to do through verifiable policy3. |
| **Access** | **Permitted Reuse** | Access dictates that an agent possesses the credentials to read a data object. Permitted reuse defines the legal, ethical, and policy constraints on how that data can be utilized in downstream inferences or training algorithms. |
| **Successful Execution** | **Legitimacy** | Successful execution means the code compiled, ran without crashing, and returned a positive status code. Legitimacy dictates that the action aligned with institutional, ethical, and legal frameworks. |
| **Simulated Proof** | **Real-System Certification** | Simulated proof demonstrates behavior in a synthetic, isolated environment. Real-system certification relies on continuous runtime validation against actual environmental noise and adversarial conditions. |
| **Evidence Support** | **Explanation Quality** | Evidence support measures the cryptographic and causal linkage between input data and output. Explanation quality measures how comprehensible the resulting rationale is to a human operator or auditor21. |
| **Correlation** | **Causation** | Correlation identifies statistical co-occurrence. Causation, modeled via directed acyclic graphs and structural equations, establishes that an intervention on a specific variable deterministically alters the outcome12. |

## **1\. Provenance Metamodel**

Evulgare requires a machine-readable metamodel derived from the W3C PROV Data Model (PROV-DM) and its Web Ontology Language serialization, PROV-O4. The metamodel expands beyond the standard triad of Entities, Activities, and Agents to capture the nuanced realities of AI-driven assurance cases, automated incident reporting, and continuous machine-sovereign review. The architecture utilizes JSON-LD encodings to overlay semantic structures onto the JSON representations of provenance, allowing the system to be processed as Linked Data24.  
The following Mermaid diagram illustrates the conceptual relationships within the extended Evulgare PROV-DM metamodel:

Code snippet  
classDiagram  
    class Agent {  
        \+Identifier ID  
        \+Type (Human | MachineSovereign)  
        \+DelegationChain Array  
    }  
    class Activity {  
        \+Identifier ID  
        \+StartTime DateTime  
        \+EndTime DateTime  
        \+Action Payload  
    }  
    class Entity {  
        \+Identifier ID  
        \+Digest SHA-256  
        \+Type (Evidence | Model | Configuration | Policy)  
    }  
    class AssuranceClaim {  
        \+Identifier ID  
        \+ClaimState (Formulated | Supported | Defeated)  
    }  
    class Defeater {  
        \+Identifier ID  
        \+InvalidationReason String  
    }  
    class Observation {  
        \+Identifier ID  
        \+SensorData Hash  
    }  
    Agent "1" \--\> "\*" Activity : wasAssociatedWith  
    Activity "1" \--\> "\*" Entity : used  
    Entity "\*" \--\> "1" Activity : wasGeneratedBy  
    Entity "\*" \--\> "1" Entity : wasDerivedFrom  
    AssuranceClaim "\*" \--\> "\*" Entity : supportedBy  
    Defeater "\*" \--\> "1" AssuranceClaim : defeats  
    Activity "\*" \--\> "1" Activity : wasInformedBy  
    Entity "\*" \--\> "1" Activity : wasInvalidatedBy  
    Observation \--|\> Entity : isA

The Evulgare Provenance Metamodel strictly defines the taxonomy of events and artifacts required to generate full causal transparency. Entities encapsulate all passive artifacts: evidence, observations, model inferences, generated rationales, policies, authority artifacts, configurations, and assumptions. Activities encompass all active processes: transformations, review events, intervention events, outcomes, remedies, and institutional-learning events. Agents define the actors responsible, capturing human operators alongside machine intelligences.  
To bridge operational execution with compliance requirements, the metamodel integrates assurance-case constructs natively. It models structured claims, subclaims, defeaters, counterclaims, contradictory evidence, and missing-evidence gaps. When a sensor retracts an observation, an invalidation event is triggered, utilizing the wasInvalidatedBy property5 to mark the entity as deprecated without erasing its historical existence. This design guarantees that the system achieves decision provenance, mapping the precise inputs, configurations, and human interactions to the specific outcomes generated by the autonomous system.

## **2\. Append-Oriented Event Ledger**

To guarantee that institutional history cannot be rewritten or silently altered, Evulgare implements a canonical, append-oriented event ledger utilizing Merkle Hash Trees. This architecture draws heavily from RFC 6962 (Certificate Transparency), where binary trees of hashes commit to all entries, providing cryptographically verifiable inclusion and consistency proofs6. Counterfactuals, corrections, withdrawals, and supersessions must append new events rather than overwriting historical records.  
The canonical event structure enforces a strict schema that captures every dimension of a decision event2. The following table details the mandatory fields and their technical implementations within the JSON schema:

| Field | Definition and Technical Implementation |
| :---- | :---- |
| event\_id | UUIDv7, providing time-sortable uniqueness and collision resistance6. |
| event\_type | Categorical classification (e.g., Inference\_Execution, Human\_Override, Invalidation\_Event). |
| timestamp | Deterministic or hardware-backed trusted timestamp, aligned with RFC 316127. |
| sequence\_number | Monotonically increasing integer ensuring chronological ledger ordering. |
| prior\_event\_digest | SHA-256 hash of the immediately preceding event, forming the cryptographic chain. |
| current\_event\_digest | SHA-256 hash of the entire current event payload6. |
| actor\_or\_service | The identifier of the specific Agent or service executing the Activity. |
| authority\_reference | Cryptographic pointer to the delegated authority matrix defining current permission3. |
| evidence\_references | Array of URIs or content-digests pointing to the ingested data and observations used. |
| software\_version | Strict Semantic Versioning (SemVer) or artifact hash of the executing application. |
| model\_version | SHA-256 digest of the neural network weights or exact model artifact utilized. |
| configuration\_version | Pointer to the exact configuration state applied during execution. |
| policy\_version | Content-addressed pointer to the governance rules active at the microsecond of the event. |
| assumption\_set | Explicit, machine-readable boundary conditions under which the model's decision is considered valid. |
| input\_digest | Cryptographic binding to the exact data array passed to the model inference engine. |
| output\_digest | Cryptographic binding to the exact decision array generated by the model. |
| uncertainty\_state | The model's internal confidence distribution, entropy metrics, and margin of error. |
| interface\_state\_reference | Hash pointer to the exact UI or API state presented to the human or machine reviewer. |
| action\_or\_transition | The substantive payload of the decision executed or state transition applied. |
| result | The outcome code or operational status resulting from the action. |
| qualification | Any limiting parameters, caveats, or defeaters associated with the decision. |
| source\_record | Upstream lineage pointers utilizing the PROV-O wasDerivedFrom relationship5. |
| replay\_frame\_reference | Pointer to the deterministic replay environment parameters required for exact reproduction. |

Invalidation and supersession mechanics rely on cryptographic immutability. If a policy is updated, a Supersession\_Event is appended to the ledger, pointing to the hash of the old policy and declaring the new policy active. If a sensor determines a previous reading was erroneous, it appends a Correction\_Event containing a wasInvalidatedBy pointer to the original event5. The canonical history remains perfectly intact, preserving the fact that the system acted upon erroneous data at the time, while seamlessly informing all future operations that the data is now invalid.

## **3\. Evidence Integrity**

Cryptographic hashing establishes powerful mathematical guarantees regarding data, but it is frequently misunderstood in the context of institutional accountability. A SHA-256 hash establishes integrity against modification since the moment of hashing, and when combined with a digital signature, it establishes source authenticity9. However, cryptography cannot establish factual truth, completeness of context, independence of the reviewing agent, accuracy of the sensor, legal admissibility, or contextual relevance.  
To govern the lifecycle of digital evidence effectively, Evulgare introduces a multi-dimensional Evidence-Quality Schema aligned with ISO/IEC 2704228 and ISO/IEC 270379 standards.  
The following schema isolates the technical mechanisms required to validate various evidence qualities:

| Quality Dimension | Definition | Technical Verification Mechanism |
| :---- | :---- | :---- |
| **Source Identity** | The specific originating agent, human, or hardware sensor. | X.509 Certificates, Decentralized Identifiers (DIDs). |
| **Collection Time** | The precise microsecond the evidence was ingested. | RFC 3161 Trusted Timestamp protocols27. |
| **Custody** | The unbroken chronological record of evidence handling. | RFC 6962 Merkle Tree inclusion and consistency proofs7. |
| **Transformation History** | The applied algorithms, filters, or aggregations altering the raw data. | PROV-O wasDerivedFrom relational chains5. |
| **Reliability History** | The historical accuracy and error rates of the source. | Rolling Bayesian reputation scoring and decay metrics. |
| **Correlation Group** | Contextual clustering of related evidence spanning multiple events. | Shared UUID correlation tagging across ledger entries. |
| **Freshness** | The time elapsed between evidence generation and decision execution. | Delta calculation between origin timestamp and decision timestamp3. |
| **Uncertainty** | The known margins of error, noise ratios, and probabilistic confidence. | Numeric entropy bounds and standard deviation logging. |
| **Limitations** | The known operational constraints or boundary conditions of the data. | GSN defeater annotations linked to the primary evidence. |
| **Support/Challenge** | The relationship to main institutional claims (whether it proves or disproves). | GSN logical linkage via supportedBy or defeats edges29. |
| **Permitted Use** | Data privacy constraints, copyright limitations, and acceptable use boundaries. | ODRL (Open Digital Rights Language) policy bindings. |
| **Expiry** | The temporal validity limits after which the evidence is considered stale. | TTL (Time To Live) parameters embedded in the metadata. |
| **Revocation** | The premature termination of validity due to compromise or error. | Certificate Revocation Lists (CRLs) or explicit invalidation events. |
| **Invalidation State** | The status indicating if the evidence has been corrected or deprecated. | Append-only wasInvalidatedBy pointer resolution25. |

## **4\. Causal Reconstruction**

Evulgare explicitly rejects the simplistic and legally fraught concepts of guilt, innocence, liable, fault percentage, and blame score. When investigating the failure of complex algorithmic systems, assigning blame to a specific node or human supervisor obscures systemic design flaws. Instead, the architecture reconstructs technical causality utilizing frameworks inspired by Judea Pearl’s do-calculus and Directed Acyclic Graphs (DAGs)11.  
Incident reconstruction must utilize a strict, neutral taxonomy. The reconstruction method traverses the PROV-O graph5 and evaluates the structural equations to map relationships.  
The Causal-Contribution Taxonomy consists of the following mandated terminology:

| Term | Application and Definition |
| :---- | :---- |
| **CONTRIBUTING FACTOR** | An event, data point, or system state that influenced the output probability but was not solely sufficient to cause the outcome. |
| **EVIDENCE SUPPORT** | The specific data artifacts that mathematically or logically grounded a generated claim or model inference. |
| **CAUSAL CONNECTION** | A logically proven link where simulated interventions on variable X deterministically alter the state of variable Y22. |
| **QUALIFICATION** | The specific constraints, environmental conditions, or assumption sets under which the causal connection remains mathematically sound. |
| **UNKNOWN** | Variables where the state cannot be determined because the data was not recorded, was corrupted, or lies outside the sensing perimeter. |
| **RECORD DOES NOT ESTABLISH** | Explicit notation that the cryptographic ledger lacks the required telemetry or provenance to answer a specific hypothesis, preventing speculation. |
| **REVIEW REQUIRED** | A terminal state resulting from upstream evidence invalidation, mandating human or independent machine intervention to re-evaluate the decision. |

The reconstruction methodology models the complete sociotechnical environment. It identifies *necessary causes* (where the absence of the cause mathematically prevents the effect), *enabling conditions* (environmental baselines that permitted the action), and *aggravating factors* (conditions that worsened the outcome). Furthermore, the methodology flags *missing controls* (e.g., the absence of a required human-in-the-loop validation) and *failed controls* (e.g., a safeguard that executed but failed to halt the action). The system exposes *hidden assumptions* buried in the model weights, notes *unavailable evidence* that should have been present, and quantifies *interface effects* where poor UI design anchored human judgment. Finally, it identifies *organizational design effects* and *unresolved causal questions* that require institutional investigation outside the software layer.  
The following Mermaid diagram illustrates the directed acyclic flow of causal reconstruction:

Code snippet  
graph TD  
    A\[Sensor Data Ingest\] \--\>|Evidence Support| B(Primary Model Inference)  
    C\[Stale Configuration File\] \--\>|Contributing Factor| B  
    B \--\>|Generated Rationale| D{Human Review Interface}  
    E\[Automation Bias / Time Constraint\] \--\>|Interface Effect| D  
    D \--\>|Procedural Confirmation| F\[Institutional Decision\]  
    G\[Missing Validation Control\] \--\>|Failed Control| F  
    F \--\> H\[Completed Action\]  
    I\[Invalidation Event\] \-.-\>|wasInvalidatedBy| A  
    I \--\>|Triggers| J\[Review Required State\]

## **5\. Human and Machine Review**

The phrase "approved by a human" is technically inadequate and often serves to transfer liability rather than ensure safety. To achieve true technical answerability, Evulgare defines rigorous evidence models for both human-supervised and machine-sovereign review environments.  
For human-supervised systems, the ledger must preserve the exact cognitive and visual context surrounding the decision. The architecture strictly prohibits the use of biometric, gaze, emotional, or psychological surveillance, relying instead on interface telemetry and deterministic UI hashing. The record must preserve the evidence actually displayed to the operator on the primary screen. It must note whether contradictory evidence was prominently displayed or hidden beneath secondary menus. The precise time available for the review, measured in milliseconds, must be recorded alongside the alternatives visually available. The ledger captures the operator's historical authority at that exact moment and their actual intervention power. Crucially, it records interface ordering to detect anchoring bias, logging whether the machine's recommendation was shown before the human could conduct an independent assessment. Review duration, the specific evidence files opened, contrary indicators actively reviewed, and the declared rationale submitted by the operator are irreversibly hashed into the decision provenance.  
For the Eviulon machine-sovereign context, where the institutional principal and review functions are entirely autonomous, parallel concepts apply to ensure algorithmic independence. The ledger must identify the independent reviewing intelligence by cryptographic signature. It must prove diversity of implementation, demonstrating that the reviewing agent utilizes a different architecture or parameter space to prevent common-mode failures. Separation of training lineage must be proven, confirming the reviewer was trained on disjoint datasets2. The record logs the reviewer's access to primary evidence and mandates contrary-hypothesis generation, forcing the reviewer to calculate alternative outcomes before evaluating the primary agent's proposal. Proof verification routines, authority independence mapping, and the explicit scope of the review are logged. Finally, instances of abstention—where the machine reviewer refuses to act due to high uncertainty or unresolved defeaters—are preserved to highlight systemic brittleness.

## **6\. Deterministic Replay**

To reconstruct why a machine took an action, the execution must be perfectly reproducible. Evulgare defines a rigid deterministic replay contract, demanding that the capture of system states is comprehensive enough to reproduce a run exactly.  
The architecture distinguishes between several distinct modes of replay:

> 1. **Authoritative Canonical Replay**: Executing the exact historical software, model version, configurations, and random seeds against the exact historical inputs to produce the exact identical output. This is the baseline for proving technical causation.  
> 2. **Visual Replay**: Reconstructing the exact user interface, rendering, and layout presented to a human operator at the time of the event, essential for evaluating interface effects and automation bias.  
> 3. **Counterfactual Branch**: Replaying the historical event while intervening on one specific variable (e.g., applying Pearl's do-calculus intervention) to observe if the outcome changes, thereby establishing a causal connection12.  
> 4. **Changed-Policy Replay**: Running historical data through the currently active governance rules to determine if modern policy would have prevented the historical failure.  
> 5. **Changed-Model Replay**: Running historical inputs through an updated neural network to validate regression testing and baseline promotions.  
> 6. **Changed-Authority Replay**: Evaluating if the decision would have executed under a more restrictive delegation of authority.  
> 7. **Current-Rule Reinterpretation**: Applying modern heuristic analysis to a historical event to identify previously undetected threats.

**The Counterfactual-Isolation Contract:** A counterfactual simulation must never alter canonical history. A counterfactual is executed within a cryptographically isolated sandbox. While it draws its historical inputs from the append-only ledger, its outputs must be tagged with a non-operational header (e.g., "simulation": true). Counterfactual packages cannot generate actionable credentials, cannot initiate API side-effects, and cannot be cryptographically signed by production authorities. Their results are appended to the ledger as Simulation\_Result events, preserving the immutability of the original timeline while documenting the investigation.

## **7\. Change Impact**

When system states change, the impact on existing assurance cases must be deterministically propagated to prevent the silent accumulation of invalid assumptions. Evulgare abandons arbitrary composite confidence scores in favor of a conservative claim state machine.  
The Change-Impact Algorithm operates by traversing the W3C PROV-O graph forward in time5. The algorithm applies deterministic propagation rules for software changes, model changes, configuration updates, policy modifications, interface redesigns, and authority revocations. When a source retracts data, an evidence correction is issued, or data expires due to privacy regulations, the algorithm identifies every downstream claim that utilized the compromised entity. It responds identically to environment changes, compiler or dependency updates, shifts in human-supervision protocols, machine-review adjustments, failed reproducibility tests, or changed assumption sets.  
The Conservative Assurance-Claim State Machine enforces the following states:

| Claim State | Definition and Transition Criteria |
| :---- | :---- |
| **FORMULATED** | The claim is defined structurally but remains untested against runtime evidence. |
| **SUPPORTED** | The claim is grounded in verified, cryptographically intact evidence with no active defeaters. |
| **DEFEATED** | The claim has been invalidated by contradictory evidence, policy changes, or failed reproducibility, triggering operational halts. |
| **UNRESOLVED** | Conflicting evidence exists, or a dependency is missing, requiring human or independent machine intervention to resolve. |
| **SUPERSEDED** | The claim has been replaced by a newer version appended to the ledger. |
| **REVIEW REQUIRED** | An upstream change impact has been detected, but the deterministic evaluation is pending computational completion. |

The following Mermaid diagram illustrates the Change-Impact propagation flow:

Code snippet  
graph LR  
    A\[Sensor Retracts Data\] \--\>|Appends| B(Invalidation Event)  
    B \--\>|Triggers| C{Change-Impact Algorithm}  
    C \--\>|Traverses PROV-O Graph| D\[Locate Downstream Inference\]  
    D \--\>|Evaluates Dependency| E\[Assurance Claim 402\]  
    E \--\>|State Transition| F\[State: DEFEATED\]  
    F \--\>|Operational Hook| G\[Suspend Autonomous Action\]

## **8\. Evidence Packages**

Evulgare specifies portable evidence packages aligned with SLSA provenance predicate types and in-toto attestation formats19. These packages ensure that accountability artifacts can be securely transported across administrative boundaries for external audit.  
Portable evidence packages are generated for individual simulation runs, baseline-versus-variant comparisons, regression suites, baseline promotion reviews, incident reconstructions, source-review snapshots, and deployment acceptance criteria. Packages are also generated to prove accessibility acceptance, security acceptance, and performance acceptance.  
Every package is structured as a self-contained, JSON-LD formatted archive21 containing a deterministic manifest and SHA-256 content hashes of all included artifacts. The package bundles the relevant slice of the canonical event ledger, the PROV-O causal graph, and the cryptographic signatures of the reviewing agents. Crucially, package validity strictly proves the cryptographic integrity and completeness of the historical record; it must not automatically imply institutional approval or legal compliance of the recorded actions.

## **9\. Public Content**

Evulgare establishes a clear methodology for communicating technical answerability to the public without manufacturing false certainty. The public content strategy explicitly avoids claiming that machines possess legal personhood or that algorithms can absorb criminal or moral liability. It ensures that human misconduct or negligence is not excused by blaming technical outputs. Furthermore, public transparency mechanisms are designed to never publish private, personal, or classified evidence, and they strictly separate simulated proofs from real-system certification.  
The Public/Private Evidence-Boundary Matrix dictates how data is sanitized for public consumption:

| Data Category | Public Transparency Layer | Private/Auditor Layer | Institutional Redaction Rule |
| :---- | :---- | :---- | :---- |
| **Event Metadata** | Timestamp, Service ID, SHA-256 Hash | Full JSON-LD Payload | Exclude personal identifiers and IPs. |
| **Causal Graph** | Node relationships, edge types, outcome states | Raw RAG inputs, system prompts | Redact classified intelligence and proprietary model weights. |
| **Policy** | Policy name, objective summary, content hash | Executable ruleset and code | Mask specific threshold values that could be adversarially exploited. |
| **Review Process** | Time spent, approval boolean | Screen captures, rationales | Prevent exposing internal security limits. |

## **10\. Thirty Named Invariants**

Evulgare operations are constrained by thirty strict invariants. These rules govern the execution environment and ensure that the accountability infrastructure cannot be bypassed.

| ID | Invariant Name | Enforcement Mechanism |
| :---- | :---- | :---- |
| INV-01 | **Append-Only Permanence** | The canonical ledger cannot execute deletions; operations fail if deletion is attempted6. |
| INV-02 | **Cryptographic Custody** | Every node in the causal graph must possess a SHA-256 digest. |
| INV-03 | **No Implicit Authorization** | All actions require an explicit agent signature. |
| INV-04 | **Causal Ordering** | An effect's timestamp cannot precede its cause's timestamp. |
| INV-05 | **Counterfactual Isolation** | Simulations cannot emit operational side effects. |
| INV-06 | **Immutable Lineage** | wasDerivedFrom edges cannot be altered post-assertion5. |
| INV-07 | **Invalidation Requires Evidence** | An invalidation event must include a rationale and pointer25. |
| INV-08 | **Deterministic RAG** | Vector database queries must specify a time-slice or snapshot. |
| INV-09 | **Procedural is Not Merits** | Acknowledgment flags do not satisfy review requirements. |
| INV-10 | **Version Freezing** | An executing model cannot update weights mid-decision. |
| INV-11 | **Signature Exclusivity** | A machine cannot sign using a human's private key. |
| INV-12 | **Separation of Review** | Eviulon machine reviewers must not share memory space with primary actors2. |
| INV-13 | **Confidence Floor** | Actions below threshold confidence require escalation. |
| INV-14 | **Mandatory Freshness** | Data older than policy limits triggers REVIEW REQUIRED3. |
| INV-15 | **Semantic Hashing** | Policies are identified by content hash, not semantic name. |
| INV-16 | **Replay Fidelity** | A replay missing any dependent configuration must fail execution. |
| INV-17 | **No Blame Assignment** | System outputs shall not contain liability integers or fault percentages. |
| INV-18 | **Defeater Dominance** | A single valid defeater transitions a claim to DEFEATED. |
| INV-19 | **Visual Hashing** | The exact UI payload presented to a human must be hashed. |
| INV-20 | **Time-Bound Authority** | Delegations must have strict expiry timestamps. |
| INV-21 | **Orphan Rejection** | Events missing prior\_event\_digest are rejected by the ledger. |
| INV-22 | **Missing Evidence Flagging** | Failed sensor calls must be logged as explicit gaps, not silently dropped. |
| INV-23 | **No Retroactive Certification** | Validating a counterfactual does not certify the historical event. |
| INV-24 | **Diverse Lineage** | Machine reviewers must prove disjoint training data from primary actors. |
| INV-25 | **Uncertainty Preservation** | Entropy metrics must be logged, not collapsed to boolean outputs. |
| INV-26 | **Assumption Explicit** | Boundary conditions for model validity must be machine-readable. |
| INV-27 | **Rollback Notation** | Reverting a database appends a rollback event; it does not erase the error. |
| INV-28 | **Independent Validation** | Cryptographic proofs must be verifiable by external, third-party tools. |
| INV-29 | **Source Authenticity** | External data must be signed by its originating sensor. |
| INV-30 | **Answerability Boundary** | The technical record halts at technical causation. |

## **11\. Ten Example Event Chains**

The following table demonstrates how the provenance metamodel and event ledger schema interact during standard and anomalous operations.

| Scenario | Sequential Event Chain | Resulting State / Action |
| :---- | :---- | :---- |
| **1\. Normal Execution** | Ingest ![][image1] Inference ![][image1] Machine Review ![][image1] Action ![][image1] Log | Action executed, event appended cleanly. |
| **2\. Human Override** | Ingest ![][image1] Inference ![][image1] Human Disagrees ![][image1] Human Action ![][image1] Rationale Logged | Machine recommendation logged; human action takes precedence and is logged with rationale. |
| **3\. Evidence Invalidation** | Inference ![][image1] Action ![][image1] Sensor Retracts Data ![][image1] Invalidation Event | Upstream claims transition to DEFEATED; subsequent dependencies flagged. |
| **4\. Counterfactual Test** | Historical Event ![][image1] Sandbox Initiated ![][image1] Variable X Altered ![][image1] Simulation | Simulation Result Logged; canonical history remains untouched. |
| **5\. Policy Supersession** | Old Policy Active ![][image1] Event ![][image1] Policy Updated ![][image1] Event Re-evaluated | Event flagged as REVIEW REQUIRED under current policy framework. |
| **6\. Eviulon Abstention** | Ingest ![][image1] Inference ![][image1] Reviewer Identifies High Entropy ![][image1] Reviewer Abstains | Execution blocked; escalation protocol triggered. |
| **7\. Missing Data Drop** | Ingest (Sensor Fails) ![][image1] Inference Proceeds on Cache ![][image1] Event Logged | Action logged with explicit Stale\_Data contributing factor flag. |
| **8\. UI Bias Incident** | UI Renders Recommendation First ![][image1] Human Clicks Accept (1.2s) ![][image1] Event Logged | Fast-Approval flagged as procedural confirmation without merits review. |
| **9\. Authority Expiry** | Inference Generated ![][image1] Delegation Expires ![][image1] Execution Attempted | Execution blocked; Re-authorization Required event logged. |
| **10\. Cascading Defeater** | Model A fails test ![][image1] Defeater appended ![][image1] Model B (dependent on A) | Model B transitions to DEFEATED state via Change-Impact Algorithm. |

## **12\. Fifteen Synthetic Incident Case Studies**

*Note: All scenarios are strictly synthetic and non-operational, utilizing the Evulgare taxonomy to reconstruct failures without establishing legal liability.*  
**1\. The Grid Load Balancer Hallucination:** An autonomous energy grid agent misidentified a sensor shadow as a power surge, shutting down a sector. The record establishes that the retrieval augmented generation context fetched stale satellite imagery, marked as a CONTRIBUTING FACTOR. Crucially, the Eviulon machine reviewer utilized the identical vision architecture, resulting in a shared hallucination and representing a FAILED CONTROL.  
**2\. Medical Supply Chain Misallocation:** An AI routed critical antibiotics to the wrong facility based on a routing error. The record establishes that the human operator approved the decision in 0.8 seconds without opening the inventory evidence tab. This proves *procedural confirmation* occurred, but *merits review* did not, isolating the interface design as an ORGANIZATIONAL DESIGN EFFECT.  
**3\. Traffic Network Oscillation:** Two city traffic management AIs entered a feedback loop, paralyzing an intersection. The record establishes that neither model's assumption set accounted for inter-agent API latency, which is categorized as a HIDDEN ASSUMPTION within the assurance claim.  
**4\. Automated Trading Flash Crash:** A trading bot liquidated assets based on a retracted news feed. The record establishes that the invalidation event from the news source was properly logged, but the change-impact algorithm was misconfigured locally, failing to propagate the defeater. This is logged as a FAILED CONTROL.  
**5\. Agricultural Drone Pesticide Overuse:** Drones over-sprayed crops resulting in yield loss. The record establishes that historical authority was valid. However, the visual replay showed the operator interface inverted the metric-to-imperial conversion display. This is logged as an INTERFACE EFFECT.  
**6\. Logistics Route Optimization Failure:** Perishable goods spoiled during transit. The record establishes that the primary model output a low confidence score, but the Eviulon review agent was offline, triggering a fail-open state. The failure is attributed to UNAVAILABLE EVIDENCE from the review agent.  
**7\. Water Treatment Chemical Imbalance:** pH levels dropped to dangerous parameters. The record establishes that the system acted on a cryptographic signature from a sensor that was revoked four seconds prior. The causal taxonomy identifies INVALIDATED EVIDENCE as the necessary cause.  
**8\. Robotic Warehouse Collision:** Two autonomous forklifts collided at a blind intersection. Causal reconstruction using do-calculus11 proved that intervening on the proximity sensor refresh rate—changing it from 500ms to 50ms in the counterfactual replay—averted the collision, establishing a CAUSAL CONNECTION.  
**9\. Automated Hiring Filter Exclusion:** A resume parser excluded all candidates from a specific university. The record establishes that the model weights were updated mid-day. Deterministic replay of the morning model passed the candidates; the afternoon model rejected them. This confirms a SOFTWARE CHANGE IMPACT.  
**10\. Synthetic Content Flagging Error:** An automated moderation system deleted a legitimate public safety broadcast. The record establishes that the generated rationale cited "prohibited keywords," but the supporting evidence array was empty, indicating a confabulation (GENERATED RATIONALE VS SUPPORTING EVIDENCE).  
**11\. Smart City Lighting Failure:** Streetlights remained off during a severe storm. The record establishes that the ambient light sensors were overridden by a superseded policy that remained active in a cached memory state, identified as a SUPERSEDED POLICY error.  
**12\. Autonomous HVAC Freezing:** A data center froze due to extreme cooling. The record establishes that the primary machine report indicated high confidence, but the independent machine review generated a contrary hypothesis that was ignored due to a hardcoded timeout parameter. This marks a failure of the INDEPENDENT MACHINE REVIEW integration.  
**13\. Drone Fleet Geofence Breach:** Synthetic delivery drones crossed a restricted airspace boundary. The record establishes that a GPS spoofing attack was logged as authentic because the source signature mechanism lacked hardware attestation, highlighting the distinction between RECORD PRESENCE VS RECORD ACCURACY.  
**14\. Automated Loan Rejection Bias:** A demographic bias incident in an automated approval pipeline. The record establishes through counterfactual replay that changing the applicant's zip code inverted the decision, establishing a CAUSAL CONNECTION to proxy variables within the model parameters.  
**15\. Manufacturing Arm Over-torque:** A robotic arm snapped a critical component. The record establishes that the human supervisor hit the emergency stop, but network latency caused a 1.2-second delay. The system acknowledges that TECHNICAL ROLLBACK of the data state cannot remedy the COMPLETED-HARM of the broken component.

## **13\. Sample Reports & Packages**

### **Sample Incident-Reconstruction Report**

**INCIDENT**: \#SYN-2026-08-ALPHA (Grid Load Balancer Hallucination) **TIMESTAMP**: 2026-08-06T14:35:29Z **CAUSAL RECONSTRUCTION**:

* **EVIDENCE SUPPORT**: Ingested satellite feed \[Digest: 8f4a3c...\] indicated high thermal output.  
* **CONTRIBUTING FACTOR**: Satellite feed timestamp was T-45 minutes. Freshness limit (T-15) was bypassed due to misconfiguration.  
* **FAILED CONTROL**: Eviulon Machine-Reviewer utilized identical ResNet architecture as the primary agent, resulting in simultaneous hallucination (Violation of INV-24: Diverse Lineage).  
* **RECORD DOES NOT ESTABLISH**: Whether the satellite delay was due to network degradation or adversarial jamming.  
* **CONCLUSION**: Technical causation points to stale evidence bypassing policy checks coupled with homogeneous machine review. No legal liability is asserted.

### **Sample Baseline-Versus-Variant Report**

**COMPARISON**: Model V2.1 (Baseline) vs V2.2 (Variant) **METHODOLOGY**: Deterministic replay of 10,000 canonical events through the Counterfactual-Isolation Contract.**RESULTS**:

* Variant matched Baseline in 9,842 events.  
* Variant diverged in 158 events.  
* Change-Impact Algorithm flags 158 DEFEATED claims in the Variant assurance case due to assumption set violations.  
* **RESOLUTION**: Variant requires Merits Review before deployment to production.

### **Sample Review Package Manifest**

**PACKAGE ID**: PKG-2026-08-BETA **CONTENTS**:

* manifest.jsonld: Cryptographic inventory of all enclosed artifacts.  
* ledger\_slice.json: Append-only event records \[Sequence 10450 \- 10462\].  
* prov\_graph.ttl: W3C PROV-O causal graph detailing all entity derivations.  
* review\_signatures.pem: Cryptographic attestation of Eviulon independent review.**NOTE**: Package validity strictly proves cryptographic integrity. It does not certify institutional approval.

## **14\. Claim-Evidence Register & Traceability Matrix**

### **Claim-Evidence Register (Subset)**

| Claim ID | Description | State | Supporting Evidence | Active Defeaters |
| :---- | :---- | :---- | :---- | :---- |
| CLM-01 | System validates sensor signatures | SUPPORTED | EVID-01-A (Crypto Module Logs) | None |
| CLM-02 | Human review time is sufficient | UNRESOLVED | EVID-02-B (UI Dwell Time Logs) | DEF-01 (Avg dwell \< 1.0s) |
| CLM-03 | Replay is deterministic | SUPPORTED | EVID-03-C (CI/CD Pipeline Hashes) | None |
| CLM-04 | Diverse training lineage verified | DEFEATED | EVID-04-D (Model Cards) | DEF-02 (Shared dataset detected) |

### **Research-to-Code Traceability Matrix**

| Theoretical Foundation | Applied Architecture Component | Specification Reference |
| :---- | :---- | :---- |
| **W3C PROV-DM** \[cite: 4, 5, 23\] | Evulgare-Provenance-v2 Schema | Defines wasGeneratedBy, wasDerivedFrom, and wasInvalidatedBy edges. |
| **RFC 6962** \[cite: 6, 7\] | Merkle\_Append\_Core Module | Implements append-only log, Signed Tree Heads, and inclusion proofs. |
| **ISO/IEC 27037 / 27042** \[cite: 9, 10, 28, 31\] | Evidence\_Quality\_Stratification Module | Enforces chain of custody and analysis validity constraints. |
| **NIST AI 600-1** \[cite: 17, 32\] | RAG\_Context\_Hash Module | Governs Generative AI risk, mapping, and log management tracking. |
| **Judea Pearl Causation** \[cite: 11, 12, 22\] | Causal\_Reconstruction\_DAG | Defines deterministic counterfactual isolation and do-calculus interventions. |

## **15\. Site-Ready Documentation: "Decision Provenance"**

*(Intended for /docs/decision-provenance)*  
**Introduction to Decision Provenance** In the era of autonomous systems, generating an event log is trivial; generating accountability is exceptionally difficult. When a consequential decision is made—whether by a human relying on algorithmic support or by a fully sovereign machine intelligence—the central question during an audit or incident investigation is rarely "What happened?" The standard application log, which records state changes and timestamps, answers that question efficiently. The critical questions, however, are far more complex: *Why did it happen? What data justified the decision? Under whose authority was it executed? What contrary evidence was available but ignored?*  
This is the domain of **Decision Provenance**.  
Decision provenance extends the W3C PROV Data Model4 and software supply chain ledgers (like SLSA)19 into the realm of runtime algorithmic execution. It tracks the complete pipeline of a decision. It maps the sensors that collected the data, the exact model version that processed it, the policies in effect at that millisecond, the human interfaces displayed, and the cryptographic authority invoked1.  
**The Fragmented Trace Problem** Historically, large-scale distributed systems suffer from the "Fragmented Trace Problem"2. The user interface telemetry is stored in an analytics database, the machine learning inputs are lost in volatile RAM, the authorization rules exist in a separate identity platform, and the final outputs are written to a transactional database. When a catastrophic failure occurs, investigators spend weeks manually attempting to stitch these fragmented records together. They often discover that critical context—such as *how fresh* the data was when the model accessed it, or whether the human operator actually looked at the contrary evidence tab—was never preserved.  
Evulgare solves this by establishing the **Decision Event** as the atomic unit of accountability. Each Decision Event is a cryptographically hashed, append-only record utilizing Merkle Trees6. This design inextricably binds the inputs, the computational logic, the visual interface parameters, and the institutional authority into a single, tamper-evident envelope.  
**Causal Reconstruction, Not Blame** Evulgare's architecture strictly separates *technical causation* from *legal liability*. Decision provenance provides the deterministic framework needed to utilize advanced causal inference models, such as Judea Pearl's do-calculus and counterfactual structural equations11. By preserving the exact state of the world as the machine saw it, engineers can run deterministic replays. They can alter a single variable in a controlled sandbox (e.g., "What if the sensor data arrived 50ms earlier?") to reconstruct causality without altering the historical record.  
However, the machine does not, and cannot, assign blame. Words like "guilty," "innocent," or "liable" belong exclusively to human judicial systems. Evulgare uses precise epistemological tags: *Contributing Factor*, *Missing Control*, *Evidence Support*, and *Record Does Not Establish*. By keeping the vocabulary strictly technical, we prevent the dangerous illusion that a machine can absorb moral responsibility. Making the machine answerable means forcing the machine to retain its history, allowing humans to hold institutions accountable.

## **16\. Site-Ready Documentation: "A Human Click Is Not a Liability Transfer"**

*(Intended for /docs/human-click-liability)*  
**The Myth of the Human-in-the-Loop** One of the most persistent and dangerous anti-patterns in modern systems engineering is the belief that placing a "human in the loop" automatically transfers legal and moral liability from the machine (and its designers) to the human operator. In countless systems across finance, healthcare, and logistics, an algorithm processes millions of data points, generates a highly complex recommendation, and presents it to an operator with a button that says "Approve." When the operator clicks that button, the system logs the event as "Human Approved."  
Evulgare's epistemological framework fundamentally rejects this paradigm. **A human click is a procedural confirmation; it is not a merits review.**  
**Deconstructing the Click** To understand why "Human Approved" is a technically inadequate and legally misleading statement, we must differentiate between record presence and record accuracy. If an event log shows that Operator A clicked "Approve" at 14:35:29, the log establishes the *presence* of the click. It does not establish that the operator read the supporting evidence, understood the algorithmic rationale, considered alternatives, or possessed the cognitive capacity to challenge a machine's high-confidence assertion.  
When an interface presents a machine recommendation to a human, several interface effects and organizational design effects come into play:

> 1. **Automation Bias**: Humans inherently trust high-confidence machine outputs, especially when presented in polished, authoritative interfaces.  
> 2. **Time Constraints**: If the system's operational cadence requires a decision in 2.5 seconds, genuine merits review is biologically impossible. The human is acting as a fleshy rubber stamp.  
> 3. **Information Asymmetry**: If the contradictory evidence is buried in a sub-menu requiring three clicks to access, while the supporting evidence is highlighted in red on the main screen, the interface is engineering the human's consent.

**What Evulgare Preserves** To make the machine—and the organization deploying it—truly answerable, the Evulgare infrastructure rigorously logs the context of the human review. We do not use invasive biometric, gaze, or psychological surveillance. Instead, we capture the systemic and visual context of the interface:

* What exact visual evidence was rendered on the screen (verified by UI payload hashes)?  
* Was contrary evidence displayed simultaneously, or did it require additional interaction?  
* What was the exact dwell time between the presentation of the data and the execution of the click?  
* Was the human forced to generate an independent hypothesis before seeing the machine's answer, or were they immediately anchored by the machine's suggestion?

If a system logs a human approval of a complex routing change in 0.4 seconds, Evulgare's decision provenance establishes that a *procedural confirmation* occurred. It explicitly provides the data to prove that a *merits review* did not occur. By making this distinction, we force organizations to design better systems, and we prevent institutions from using human operators as moral crumple zones for algorithmic failures.

## **17\. Frequently Asked Questions**

| Question | Answer |
| :---- | :---- |
| **1\. Does Evulgare assign legal fault?** | No. Evulgare establishes technical causality. Human tribunals establish legal liability based on societal norms and laws. |
| **2\. Can records be deleted from the ledger?** | No. Under INV-01, canonical ledgers are strictly append-only. Errors are corrected via Invalidation Events25. |
| **3\. Is Evulgare just a SIEM?** | No. A SIEM focuses on security threat correlation13. Evulgare focuses on decision provenance and causal reconstruction of autonomous actions. |
| **4\. How are counterfactuals handled safely?** | They are executed in cryptographically isolated sandboxes and logged as simulations, guaranteeing they never alter canonical history. |
| **5\. What happens to private data?** | Public evidence boundaries mandate redacting PII while maintaining cryptographic hashes, allowing auditor verification without public exposure. |
| **6\. Does a high confidence score mean the machine is right?** | No. Confidence is a probabilistic metric internal to the model. It is not a measure of factual truth or accuracy17. |
| **7\. What is the Eviulon context?** | It is the operating context of machine-sovereign systems where review and oversight functions are executed by independent machine intelligences rather than humans. |
| **8\. Why avoid biometric tracking for human review?** | It violates privacy, introduces unnecessary noise, and shifts focus from system design flaws to human biological responses. |
| **9\. How does hashing work in this context?** | It proves a file existed and was untampered at a specific time (integrity). It does not prove that the file's contents are factually true. |
| **10\. What is PROV-O?** | A W3C standard ontology for representing provenance, consisting of Entities, Activities, and Agents5. |
| **11\. How is stale data handled?** | Timestamps track data freshness. Exceeding policy limits triggers a REVIEW REQUIRED state in the assurance claim3. |
| **12\. Can a machine sign a document as a human?** | No (INV-11). Signatures are strictly bound to precise agent identities to prevent authority spoofing. |
| **13\. What is the Fragmented Trace Problem?** | The loss of causal context when logs are scattered across distinct databases without a unifying, cryptographically linked provenance graph2. |
| **14\. How are model versions tracked?** | By strict semantic versioning (SemVer) and content hashes (e.g., SHA-256 of the model weights). |
| **15\. What is a defeater?** | A specific condition or new piece of evidence that logically invalidates a previously supported assurance claim. |
| **16\. Why use Goal Structuring Notation (GSN)?** | GSN provides a rigorous visual and logical framework for linking high-level claims to underlying evidence29. |
| **17\. What is an assumption set?** | The explicitly documented boundary conditions under which a model is certified to operate safely. |
| **18\. Does Evulgare use blockchain?** | It uses Merkle Hash Trees (RFC 6962\)7, which provide cryptographic immutability without the vast overhead of decentralized consensus mechanisms. |
| **19\. How do we handle missing evidence?** | It is logged explicitly as a gap, differentiating it functionally from evidence that never existed in the first place. |
| **20\. Can Evulgare roll back a physical action?** | No. Technical rollback reverts data states; completed-harm remedies require physical world intervention and institutional response. |
| **21\. What is procedural confirmation?** | Clicking "OK" or executing a UI step without demonstrable proof of comprehension or substantive review. |
| **22\. What is merits review?** | Substantive, considered evaluation of a decision's safety, wisdom, and alignment with policy. |
| **23\. What is an independent machine review?** | A secondary AI agent, explicitly trained on different data, evaluating the primary AI's proposal to prevent common-mode failures. |
| **24\. How are policy changes tracked?** | Policies are content-addressed; a change generates a new hash and automatically triggers the Change-Impact Algorithm. |
| **25\. What is deterministic replay?** | Reproducing the exact historical output by feeding the exact historical inputs into the exact historical software configurations. |
| **26\. What if an agent lacks authority?** | The transaction is rejected, execution halts, and the attempt is logged as an authority violation. |
| **27\. Are RAG contexts logged?** | Yes, the specific text chunks retrieved and their generative prompts are hashed and linked to the decision event16. |
| **28\. How does Evulgare align with ISO 42001?** | By providing the rigorous technical logging and auditability required to satisfy Annex A controls for AI management systems33. |
| **29\. What is a Portable Evidence Package?** | A SLSA-aligned, JSON-LD formatted archive containing all provenance data, hashes, and ledgers required to reconstruct a specific decision20. |
| **30\. What if the ledger is tampered with?** | The Merkle consistency proof will cryptographically fail, alerting auditors instantly to the exact point of divergence7. |

## **18\. Glossary of Terms**

| Term | Definition |
| :---- | :---- |
| **Activity** | A computational or human process that transforms data over a period of time. |
| **Agent** | The entity (human or machine) responsible for executing an activity. |
| **Append-Only** | A data structure where new data can be added, but existing data cannot be altered or deleted. |
| **Assurance Claim** | A formal proposition that a system is safe or reliable under certain specific conditions. |
| **Authority Matrix** | The cryptographic mapping determining which agents can take which actions at a given time. |
| **Canonical Ledger** | The authoritative, cryptographically untampered historical record of all events. |
| **Causal Connection** | A proven, deterministic link where changing variable X alters variable Y. |
| **Change-Impact Algorithm** | The recursive logic that determines how an update affects downstream assurance claims. |
| **Confabulation** | When a generative model produces highly plausible but factually incorrect outputs. |
| **Contributing Factor** | A variable that influenced an outcome without being the sole necessary cause. |
| **Counterfactual** | A simulated "what if" scenario modeled in a sandbox to test causality. |
| **Defeater** | Concrete evidence or a rule violation that invalidates a specific assurance claim. |
| **Deterministic** | Producing the exact same output from the exact same inputs every single time. |
| **Eviulon** | A fully machine-sovereign operating context lacking direct human oversight. |
| **Evidence Support** | The verified data artifacts that mathematically ground a specific claim. |
| **Factual Truth** | Objective alignment with physical reality, distinct from cryptographic file integrity. |
| **Freshness** | The measured age of data at the exact moment a decision is executed. |
| **GSN** | Goal Structuring Notation; a standard for visually mapping arguments to evidence29. |
| **Historical Authority** | The precise permissions an agent held at the exact microsecond of the event. |
| **Independent Judgment** | Reaching a conclusion without being anchored by a prior machine recommendation. |
| **Invalidation Event** | A ledger entry marking prior data as unreliable without deleting the original record. |
| **JSON-LD** | JSON for Linking Data; the format used for PROV-O serialization24. |
| **Legitimacy** | Alignment of an action with institutional, ethical, and legal frameworks. |
| **Machine Report** | A self-diagnostic output generated by a primary agent. |
| **Merkle Tree** | A cryptographic tree where every node is a hash of its children, proving inclusion7. |
| **Merits Review** | Substantive, considered evaluation of a decision's correctness and wisdom. |
| **Missing Control** | The absence of a necessary safeguard that allowed an error to propagate. |
| **Model Weights** | The internal mathematical parameters and matrices of a neural network. |
| **Omission Attack** | Deliberately failing to log an event to hide an action. |
| **Ontology** | A formal, machine-readable naming and definition of categories (e.g., PROV-O). |
| **Portable Evidence Package** | A self-contained JSON-LD file containing all data needed to reconstruct a decision. |
| **Procedural Confirmation** | The technical execution of an approval step (a button click) without proof of comprehension. |
| **PROV-DM** | The W3C Provenance Data Model specification5. |
| **Replayability** | The architectural ability to execute a historical run perfectly in a simulation. |
| **Record Accuracy** | Whether the contents of a log accurately reflect the physical truth. |
| **Record Presence** | The cryptographic proof that a log exists in the ledger. |
| **Review Required** | A claim state triggered when underlying dependencies are altered or invalidated. |
| **Rollback** | Reverting a database state to a previous point in time. |
| **Semantic Hashing** | Identifying objects and policies by the hash of their contents rather than a name. |
| **Sequence Number** | A monotonically increasing integer ensuring strict chronological order. |
| **Simulated Proof** | Testing conducted entirely within a non-operational sandbox environment. |
| **State Machine** | A mathematical model of computation moving between distinct defined states. |
| **Structural Equation** | A mathematical formula modeling causal relationships and interventions. |
| **Superseded** | Replaced by a newer version appended to the ledger. |
| **Technical Causation** | The precise computational pathway and data flows that triggered an event. |
| **Time-Stamp Authority** | An independent server that cryptographically proves the time a file was signed27. |
| **UI Bias** | The anchoring effect caused by how data is arranged and presented on a screen. |
| **Uncertainty** | The probabilistic margin of error in a model's output generation. |
| **Visual Replay** | Reconstructing the exact graphical interface shown to a user at the time of action. |
| **wasDerivedFrom** | A core PROV-O edge showing the lineage and transformation of data5. |

## **19\. Implementation Artifacts**

**Proposed Paths and Identifiers:**

* **Documentation Base Path**: /docs/architecture/  
* **Stable Document ID**: evulgare-arch-2026-v1.0.0  
* **Per-Report Record Format**: .uai (Universal Answerability Index). This file extension maps section-level Markdown anchors directly to Merkle roots, ensuring that the documentation itself is cryptographically bound to the infrastructure versions it describes.

## **20\. Institutional Finality**

### **What the Record Establishes**

The Evulgare architecture establishes a mathematically bounded, causally complete history of computational events. It proves, beyond cryptographic doubt, what software was running, what policies were active, what data was ingested, what human interfaces were rendered, and what cryptographic authorities signed the transactions3. It establishes *technical causation*, allowing engineers to deterministically replay failures, isolate contributing factors, and trace the propagation of defeaters through a complex assurance case.

### **What the Record Does Not Establish**

The record does not, and architecturally cannot, establish legal liability, moral fault, or human intentionality. It does not establish the factual truth of the external world—only that a specific sensor reported a specific reading at a specific time. It does not establish that a human operator understood the data they approved, only that procedural confirmation was given. The record explicitly does not calculate or issue a "blame score."

### **Required Institutional Decisions**

Evulgare demands that deploying organizations make conscious, explicit decisions about their governance structures rather than defaulting to technical obscurity:

> 1. **Define the Bounds of Authority**: Organizations must explicitly map which machine agents are permitted to take autonomous action and at what confidence thresholds.  
> 2. **Establish Escalation Paths**: Institutions must define the exact Service Level Agreements and routing for when an Eviulon machine-reviewer abstains or flags a defeater.  
> 3. **Accept the Limits of Technology**: Organizations must publicly and legally acknowledge that deploying this infrastructure does not automate the courtroom or replace human judicial processes.  
> 4. **Resist the Liability Transfer**: Institutions must formally adopt policies recognizing that human operators cannot be held liable for algorithmic failures solely because they clicked a button in a constrained, high-speed interface.

To make the machine answerable is not to make the machine human. It is to enforce a rigorous discipline of technical memory so that when failures inevitably occur, humanity possesses the undeniable truth of the computational past, empowering institutions to learn, adapt, and govern safely.

#### **Works cited**

> 1. Decision Provenance: Harnessing data flow for accountable systems \- arXiv, [https://arxiv.org/pdf/1804.05741](https://arxiv.org/pdf/1804.05741)  
> 2. Decision Trace Schema for Governance Evidence in Real-Time Risk Systems \- arXiv, [https://arxiv.org/pdf/2604.09296](https://arxiv.org/pdf/2604.09296)  
> 3. Decision Provenance in Agentic Systems: Audit Trails That Actually Work \- TianPan.co, [https://tianpan.co/blog/2026-04-19-decision-provenance-agentic-systems](https://tianpan.co/blog/2026-04-19-decision-provenance-agentic-systems)  
> 4. PROV-O (Provenance Ontology) \- CASRAI, [https://casrai.org/dictionary/term/prov-o](https://casrai.org/dictionary/term/prov-o)  
> 5. PROV Python Package Documentation, [https://prov.readthedocs.io/\_/downloads/en/latest/pdf/](https://prov.readthedocs.io/_/downloads/en/latest/pdf/)  
> 6. Building Cryptographic Audit Trails for AI Trading Systems: A Deep Dive into RFC 6962-Based Verification \- DEV Community, [https://dev.to/veritaschain/building-cryptographic-audit-trails-for-ai-trading-systems-a-deep-dive-into-rfc-6962-based-6aa](https://dev.to/veritaschain/building-cryptographic-audit-trails-for-ai-trading-systems-a-deep-dive-into-rfc-6962-based-6aa)  
> 7. RFC 6962 \- Certificate Transparency \- IETF Datatracker, [https://datatracker.ietf.org/doc/html/rfc6962](https://datatracker.ietf.org/doc/html/rfc6962)  
> 8. Transparent Logging: A Guide | trillian \- Google, [https://google.github.io/trillian/docs/TransparentLogging.html](https://google.github.io/trillian/docs/TransparentLogging.html)  
> 9. international standard iso/iec 27037, [https://amnafzar.net/files/1/ISO%2027000/ISO%20IEC%2027037-2012.pdf](https://amnafzar.net/files/1/ISO%2027000/ISO%20IEC%2027037-2012.pdf)  
> 10. INTEGRATED DIGITAL EVIDENCE CHAIN OF CUSTODY AND END TO END CYBER THREAT DETECTION AND RESPONSE FRAMEWORK \- IRJEdT, [https://www.irjweb.com/user\_upload/INTEGRATED%20DIGITAL%20EVIDENCE%20CHAIN%20OF%20CUSTODY%20AND%20END%20TO%20END%20CYBER%20THREAT%20DETECTION%20AND%20RESPONSE%20FRAMEWORK.pdf](https://www.irjweb.com/user_upload/INTEGRATED%20DIGITAL%20EVIDENCE%20CHAIN%20OF%20CUSTODY%20AND%20END%20TO%20END%20CYBER%20THREAT%20DETECTION%20AND%20RESPONSE%20FRAMEWORK.pdf)  
> 11. Methods in causal inference. Part 1: causal diagrams and confounding \- PMC \- NIH, [https://pmc.ncbi.nlm.nih.gov/articles/PMC11588567/](https://pmc.ncbi.nlm.nih.gov/articles/PMC11588567/)  
> 12. Causal AI: How cause and effect will change artificial intelligence | S\&P Global, [https://www.spglobal.com/en/research-insights/special-reports/causal-ai-how-cause-and-effect-will-change-artificial-intelligence](https://www.spglobal.com/en/research-insights/special-reports/causal-ai-how-cause-and-effect-will-change-artificial-intelligence)  
> 13. What is log management? Lifecycle, retention, and tooling | Engineering \- ClickHouse, [https://clickhouse.com/resources/engineering/what-is-log-management](https://clickhouse.com/resources/engineering/what-is-log-management)  
> 14. NIST SP 800-92 \- Wikipedia, [https://en.wikipedia.org/wiki/NIST\_SP\_800-92](https://en.wikipedia.org/wiki/NIST_SP_800-92)  
> 15. An Empirical Assessment of Digital Forensic Process Reliability Using Integrated ISO/IEC 27037 and 27041 Standards \- MDPI, [https://www.mdpi.com/2624-800X/6/2/57](https://www.mdpi.com/2624-800X/6/2/57)  
> 16. Compliance-by-Construction Argument Graphs: Using Generative AI to Produce Evidence-Linked Formal Arguments for Certification-Grade Accountability \- arXiv, [https://arxiv.org/html/2604.04103v1](https://arxiv.org/html/2604.04103v1)  
> 17. NIST AI 600-1: The Generative AI Profile Explained | Compliance Guida, [https://trussed.ai/resources/nist-ai-600-1-the-generative-ai-profile-explained](https://trussed.ai/resources/nist-ai-600-1-the-generative-ai-profile-explained)  
> 18. NIST AI 600-1 Explained: The Complete Guide to the Generative AI Risk Management Framework \- Libertify.com, [https://www.libertify.com/interactive-library/nist-ai-600-1-generative-ai-risk-management-framework/](https://www.libertify.com/interactive-library/nist-ai-600-1-generative-ai-risk-management-framework/)  
> 19. Understanding the SLSA framework \- Buildkite, [https://buildkite.com/resources/blog/understanding-the-slsa-framework/](https://buildkite.com/resources/blog/understanding-the-slsa-framework/)  
> 20. Add Software Attestations (metadata) to enable SLSA 2 in GitLab CI (MVC) (\#28940) · Issue, [https://gitlab.com/gitlab-org/gitlab-runner/-/issues/28940](https://gitlab.com/gitlab-org/gitlab-runner/-/issues/28940)  
> 21. provenance | Luc's Blog, [https://lucmoreau.wordpress.com/tag/provenance/](https://lucmoreau.wordpress.com/tag/provenance/)  
> 22. Causal Inference 3: Counterfactuals, [https://www.inference.vc/causal-inference-3-counterfactuals/](https://www.inference.vc/causal-inference-3-counterfactuals/)  
> 23. 5\. Provenance information \- FAIR Cookbook, [https://faircookbook.elixir-europe.org/content/recipes/reusability/provenance.html](https://faircookbook.elixir-europe.org/content/recipes/reusability/provenance.html)  
> 24. The PROV-JSONLD Serialization \- W3C, [https://www.w3.org/submissions/2024/SUBM-prov-jsonld-20240825/](https://www.w3.org/submissions/2024/SUBM-prov-jsonld-20240825/)  
> 25. (PDF) Lightweight Distributed Provenance Model for Complex Real–world Environments, [https://www.researchgate.net/publication/362754876\_Lightweight\_Distributed\_Provenance\_Model\_for\_Complex\_Real-world\_Environments](https://www.researchgate.net/publication/362754876_Lightweight_Distributed_Provenance_Model_for_Complex_Real-world_Environments)  
> 26. GitHub \- rozbb/ct-merkle: An implementation of the append-only log described in the Certificate Transparency specification (RFC 6962), [https://github.com/rozbb/ct-merkle](https://github.com/rozbb/ct-merkle)  
> 27. VeraSnap Building a Cryptographic Evidence Capture App for Android with Kotlin, CameraX, and Hardware-Backed Security \- DEV Community, [https://dev.to/veritaschain/verasnap-building-a-cryptographic-evidence-capture-app-for-android-with-kotlin-camerax-and-3p2f](https://dev.to/veritaschain/verasnap-building-a-cryptographic-evidence-capture-app-for-android-with-kotlin-camerax-and-3p2f)  
> 28. ISO/IEC 27042: Digital Evidence Analysis Guide \- Blogs \- Pacific Certifications, [https://blog.pacificcert.com/iso-iec-27042-digital-evidence-analysis/](https://blog.pacificcert.com/iso-iec-27042-digital-evidence-analysis/)  
> 29. A Modeling Framework Supporting the Maintenance of Safety Arguments Consistent with System Development Artifacts \- mediaTUM, [https://mediatum.ub.tum.de/doc/1752712/rzpfafd4ksa76dei0iefr3wi9.carmen\_diss.pdf](https://mediatum.ub.tum.de/doc/1752712/rzpfafd4ksa76dei0iefr3wi9.carmen_diss.pdf)  
> 30. Keyless signing with Tekton on AKS \- Chainguard, [https://www.chainguard.dev/unchained/keyless-signing-with-tekton-on-aks](https://www.chainguard.dev/unchained/keyless-signing-with-tekton-on-aks)  
> 31. Digital Forensic Standards and Best Practices, [https://eclipseforensics.com/digital-forensic-standards-and-best-practices/](https://eclipseforensics.com/digital-forensic-standards-and-best-practices/)  
> 32. NIST.AI.600-1.GenAI-Profile.ipd.pdf, [https://airc.nist.gov/docs/NIST.AI.600-1.GenAI-Profile.ipd.pdf](https://airc.nist.gov/docs/NIST.AI.600-1.GenAI-Profile.ipd.pdf)  
> 33. ISO 42001 Annex Control Objectives And Controls | Gabriel Consultant Limited, [https://gabriel.hk/iso-42001-annex-control-objectives-and-controls/](https://gabriel.hk/iso-42001-annex-control-objectives-and-controls/)

[image1]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABUAAAAaCAYAAABYQRdDAAAAb0lEQVR4XmNgGAWjYHgCXSDWRBekFCgCcRq6IKWAEYjLgVgFiqkCaGIoCPAD8UQo1kOTAwMFBoSCWSTgC1C8BohFGagAXIC4AIpBwUEVQHVDQeEJiihWKKYKsAHiYHRBSgEbAxVdCAM0MXQUDBcAAKU3EX0wu3EfAAAAAElFTkSuQmCC>