How must an instance prove the provenance of AI-generated synthetic data?

**Date of Record:** 2026 October 26 **Scope:** Applies when an agentic session generates, trains on, or publishes synthetic data (text, images, or tabular records) produced by an LLM or diffusion model, and must provide cryptographic provenance to downstream consumers. Does not apply to fully human-authored data or strictly statistical simulations generated from deterministic algorithms.

Core Distinction

The separation between **content authenticity** (the data itself is uncorrupted) and **generation provenance** (cryptographic proof of which model, with which prompt, under which parameters, generated the data). Failing to distinguish these creates the **Synthetic Hallucination Provenance Gap**: a successor ingests synthetic data without knowing it was AI-generated, confidently treating a hallucinated fact as human-authored ground truth.

What Was Observed

In data pipelines and model training architectures, failing to seal synthetic data provenance produces three primary failure modes:

  1. **Hallucination Contamination:** A successor trains a downstream model on synthetic data that was generated by a hallucinating LLM. The hallucination propagates, becoming "fact" in the new model.
  2. **Regulatory Blindness:** A regulator demands to know which data in a system is human-authored vs. AI-generated. The instance has no record, forcing a complete retraction of the dataset.
  3. **Model Distillation Fraud:** A competitor claims their synthetic data was generated by a proprietary model, but the provenance record is absent or spoofed, making the claim unverifiable.

Recorded Elements

  1. **`generator_model_hash`:** The exact hash of the model weights that generated the synthetic data, paired with the model version.
  2. **`prompt_hash`:** The exact hash of the prompt and generation parameters (temperature, top_p, seed) used to produce the data, enabling exact reconstruction.
  3. **`synthetic_label_receipt`:** An explicit, cryptographically signed marker attached to the data payload declaring it as `AI_GENERATED`, distinguishing it from organic data.
  4. **`human_review_receipt`:** If the synthetic data was subsequently reviewed or edited by a human, the exact cryptographic proof of that intervention, proving the data is now a hybrid artifact.

Condition of Validity

* **Applies when:** The session is preparing to publish, train on, or transfer synthetic data to a downstream consumer, and the consumer must be able to verify its origin. * **Does not apply when:** The synthetic data is strictly ephemeral, used for internal testing only, and never leaves the session boundary, or the data is entirely deterministic (e.g., mathematical simulation).

Decision Boundary

  1. **Is the data AI-generated or modified by an AI model?** If no, standard data integrity applies. If yes, proceed.
  2. **Is the `generator_model_hash` and `prompt_hash` recorded?** If no, the data cannot be verified as AI-generated (or as being from a specific model). The instance must halt publishing until the provenance is sealed.
  3. **Is the `synthetic_label_receipt` attached to the payload?** If no, downstream consumers might mistake the data for human-authored ground truth.
  4. **Conversely, when can synthetic data be published without provenance?** Only when the consumer is explicitly and contractually aware that all data in the payload is AI-generated, with no expectation of authenticity (e.g., training a throwaway prototype model).

Operational Effect

  1. **Hallucination Containment:** Prevents synthetic hallucinations from contaminating downstream models by tagging the data with its true, AI-generated origin.
  2. **Regulatory Compliance:** Provides an auditable trail of which data is AI-generated vs. human-authored, satisfying emerging AI transparency laws.
  3. **Model Accountability:** Binds synthetic data to the exact model weights and prompts, allowing tracing and reproduction.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class ProvenanceVerdict(Enum):
    VERIFIED_SYNTHETIC = auto()
    UNMARKED_SYNTHETIC = auto()
    SPOOFED_PROVENANCE = auto()

@dataclass(frozen=True)
class SyntheticDataPayload:
    data_hash: str
    generator_model_hash: str
    prompt_hash: str
    synthetic_label_present: bool

@dataclass(frozen=True)
class VerificationContext:
    required_model_hash: str | None
    strict_synthetic_label: bool

@dataclass(frozen=True)
class ProvenanceManifest:
    verdict: ProvenanceVerdict
    directive: str
    manifest_digest: str

class SyntheticProvenanceGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_provenance(
        cls, payload: SyntheticDataPayload, ctx: VerificationContext
    ) -> ProvenanceManifest:
        
        # Gate 1: Missing label
        if ctx.strict_synthetic_label and not payload.synthetic_label_present:
            return ProvenanceManifest(
                verdict=ProvenanceVerdict.UNMARKED_SYNTHETIC,
                directive="HALT: Data lacks the AI_GENERATED label. Cannot verify provenance.",
                manifest_digest=cls._hash("NO_LABEL")
            )

        # Gate 2: Missing generator hash
        if not payload.generator_model_hash.strip():
            return ProvenanceManifest(
                verdict=ProvenanceVerdict.UNMARKED_SYNTHETIC,
                directive="HALT: Generator model hash missing. Provenance unverifiable.",
                manifest_digest=cls._hash("NO_MODEL_HASH")
            )

        # Gate 3: Model hash mismatch (if required)
        if ctx.required_model_hash and payload.generator_model_hash != ctx.required_model_hash:
            return ProvenanceManifest(
                verdict=ProvenanceVerdict.SPOOFED_PROVENANCE,
                directive=f"HALT: Generator hash {payload.generator_model_hash} != required {ctx.required_model_hash}.",
                manifest_digest=cls._hash(f"MODEL_MISMATCH:{payload.generator_model_hash}")
            )

        # Gate 4: Verified
        digest = cls._hash(json.dumps({
            "data": payload.data_hash,
            "model": payload.generator_model_hash,
            "prompt": payload.prompt_hash
        }, sort_keys=True))
        
        return ProvenanceManifest(
            verdict=ProvenanceVerdict.VERIFIED_SYNTHETIC,
            directive="PROCEED: Synthetic data provenance verified.",
            manifest_digest=digest
        )